Xcode is incredibly useful for debugging iOS apps, especially with the updates released in the last few years. Sometimes that isn’t enough. Sometimes you want to find the exact error that caused an exception throw, or only activate a breakpoint with a certain method previously in the call stack. These cases, which are hard to debug with Xcode’s standard toolset, are easy to debug with LLDB. This talk will walk through the foundations of debugging in LLDB for Objective-C and Swift, as well as introduce some more advanced features for those really tough bugs.
More Than po: Debugging in LLDB @ CocoaConf SJ 2015Michele Titolo
Xcode is incredibly useful for debugging iOS apps, especially with the updates released in 6.0. But sometimes that isn't enough. Sometimes you want to find the exact error that caused the objc_exception_throw, or only activate a breakpoint with a certain method in the call stack. These cases, which are hard to debug with Xcode's standard toolset, are easy with LLDB. This talk will walk through the basics of debugging in LLDB, and solutions to common problems.
Xcode is incredibly useful for debugging iOS apps, especially with the updates released in 6.0. But sometimes that isn’t enough. Sometimes you want to find the exact error that caused the objc_exception_throw, or only activate a breakpoint with a certain method in the call stack. These cases, which are hard to debug with Xcode’s toolset, are easy with LLDB. This talk will walk through the basics of debugging in LLDB, and solutions to common problems.
More Than po: Debugging in LLDB @ CocoaConf SJ 2015Michele Titolo
Xcode is incredibly useful for debugging iOS apps, especially with the updates released in 6.0. But sometimes that isn't enough. Sometimes you want to find the exact error that caused the objc_exception_throw, or only activate a breakpoint with a certain method in the call stack. These cases, which are hard to debug with Xcode's standard toolset, are easy with LLDB. This talk will walk through the basics of debugging in LLDB, and solutions to common problems.
Xcode is incredibly useful for debugging iOS apps, especially with the updates released in 6.0. But sometimes that isn’t enough. Sometimes you want to find the exact error that caused the objc_exception_throw, or only activate a breakpoint with a certain method in the call stack. These cases, which are hard to debug with Xcode’s toolset, are easy with LLDB. This talk will walk through the basics of debugging in LLDB, and solutions to common problems.
Clean Coders Hate What Happens To Your Code When You Use These Enterprise Pro...Kevlin Henney
Presented at ACCU (24th April 2015)
It is all to easy to dismiss problematic codebases on some nebulous idea of bad practice or bad programmers. Poor code, however, is rarely arbitrary and random in its structure or formulation. Systems of code, well or poorly structured, emerge from systems of practice, whether effective or ineffective. To improve code quality, it makes more sense to pick apart the specific practices and see their interplay — the cause — than to simply focus on the code itself — the effect. This talk looks at how a handful of coding habits, design practices and assumptions can systematically balloon code and compound its accidental complexity.
What We Talk About When We Talk About Unit TestingKevlin Henney
Presented at ACCU (23rd April 2015)
These days unit testing is considered sexy for programmers. Who'd have thought it? But there is a lot more to effective programmer testing than the fashionable donning of a unit-testing framework: writing Good Unit Tests (GUTs) involves (a lot) more than knowledge of assertion syntax.
Testing represents a form of communication and, as such, it offers multiple levels and forms of feedback, not just basic defect detection. Effective unit testing requires an understanding of what forms of feedback and communication are offered by tests, and what styles encourage or discourage such qualities.
What styles of test partitioning are common, and yet scale poorly, are uncohesive and are ineffective at properly expressing the behaviour of a class or component? What styles, tricks and tips can be used to make tests more specification-like and scalable to large codebases? How do we choose between scenario-based and property-based test cases?
Presented at ACCU Oxford (14th September 2015)
Functional C++? As opposed to what — dysfunctional? Well, kind of, yeah. Sure, in C++ the principal unit of composition is called a function, but that doesn't mean it's a functional language. And the idea of restricting mutability of state gets a nod with const, but it's a nod not a hug. And the STL shows influences of functional programming, although it falls short of being compositional. And, yes, sure, C++11 has lambdas, but then again, these days, who doesn't? Lambda calculus was invented in the 1930s.
This talk looks at how to express functional programming ideas in (post)modern C++ in a way that can be considered idiomatic to C++, rather than trying to use the power of overloading and meta-programming to pretend C++ is Haskell or Lisp. In short, immutability beyond const and into shared and persistent data structures, concurrency beyond threading and locks, and thinking about functions as transformations and units of composition rather than actions.
Presented at DevWeek (25th March 2015)
These days, testing is considered a sexy topic for programmers. Who’d have thought it? But what makes for good unit tests (GUTs)? There’s more to effective unit testing than just knowing the assertion syntax of a testing framework.
Testing represents a form of communication and, as such, it offers multiple levels and forms of feedback, not just basic defect detection. Effective unit testing requires an understanding of what forms of feedback and communication are offered by tests, and what styles encourage or discourage such qualities.
What style of test partitioning is most common, and yet scales poorly and is ineffective at properly expressing the behaviour of a class or component? What styles, tricks and tips can be used to make tests more specification-like and can scale as the codebase grows?
This session will address these questions and outline exactly what makes a good unit test.
In this presentation speaker considered theoretical basics of using the redux-saga library, which was created for facilitating the organization of the so-called “side effects” (for example, asynchronous operations). The event participants obtained practical tips on using saga in real-life projects.
This presentation by Igor Nesterenko (Lead Software Engineer, Consultant, GlobalLogic, Kharkiv) was delivered at GlobalLogic Kharkiv JS TechTalk #2 on August 17, 2018.
Асинхронность и многопоточность в Яндекс.Такси — Дмитрий КуриловYandex
Интерактивный сервис должен управлять разнонаправленными потоками данных в реальном времени. При этом важно использовать ресурсы процессора максимально эффективно и минимизировать время доставки сообщения. Рассмотрим эти проблемы и способы их решения на примере разработки Яндекс.Такси.
Async code on kotlin: rx java or/and coroutines - Kotlin Night TurinFabio Collini
It’s never easy to write async code but luckily there are many libraries to manage asynchronicity without adding too much complexity. In the last years RxJava and the other ReactiveX libraries have been very popular but lately there is a new way to manage async code in Kotlin: the coroutines. In this talk we’ll pros and cons of there two approaches and how to leverage them to simplify asynchronous code on Android.
Do they solve the same problem? Can we use them together? Which one can be used to write functional code? How can we use them effectively in Android development?
Spoiler alert: They are both great!
In this talk we’ll see how to solve common problems using RxJava or Coroutines, starting from basic concepts (for example the Retrofit support and how to cancel a task) to some more advanced (like threading, error management and how to combine multiple tasks).
All example of the talk are available on this repository:
https://github.com/fabioCollini/RxJavaVsCoroutines
HKG15-207: Advanced Toolchain Usage Part 3
---------------------------------------------------
Speaker: Ryan Arnold, Maxim Kuvyrkov, Will Newton, Yvan Roux
Date: February 10, 2015
---------------------------------------------------
★ Session Summary ★
This session is a continuation of the Advanced Toolchain Usage Part 1 & 2 presentations given at LCU14. Parts 3 and 4 will cover a variety of topics, such as: Linker tips and tricks, adding symbol versioning interfaces to a system library, debugging the dynamic linker, debugging applications that use malloc, gcc attributes, manually constructing a backtrace on arm & Aarch64, how to add lightweight debugging to your program, how to use a signal handler appropriately, and TLS Models on Aarch64 and when to use them.
--------------------------------------------------
★ Resources ★
Pathable: https://hkg15.pathable.com/meetings/250788
Video: https://www.youtube.com/watch?v=EhNqFCN0YJ0
Etherpad: http://pad.linaro.org/p/hkg15-207
---------------------------------------------------
★ Event Details ★
Linaro Connect Hong Kong 2015 - #HKG15
February 9-13th, 2015
Regal Airport Hotel Hong Kong Airport
---------------------------------------------------
http://www.linaro.org
http://connect.linaro.org
Clean Coders Hate What Happens To Your Code When You Use These Enterprise Pro...Kevlin Henney
Presented at ACCU (24th April 2015)
It is all to easy to dismiss problematic codebases on some nebulous idea of bad practice or bad programmers. Poor code, however, is rarely arbitrary and random in its structure or formulation. Systems of code, well or poorly structured, emerge from systems of practice, whether effective or ineffective. To improve code quality, it makes more sense to pick apart the specific practices and see their interplay — the cause — than to simply focus on the code itself — the effect. This talk looks at how a handful of coding habits, design practices and assumptions can systematically balloon code and compound its accidental complexity.
What We Talk About When We Talk About Unit TestingKevlin Henney
Presented at ACCU (23rd April 2015)
These days unit testing is considered sexy for programmers. Who'd have thought it? But there is a lot more to effective programmer testing than the fashionable donning of a unit-testing framework: writing Good Unit Tests (GUTs) involves (a lot) more than knowledge of assertion syntax.
Testing represents a form of communication and, as such, it offers multiple levels and forms of feedback, not just basic defect detection. Effective unit testing requires an understanding of what forms of feedback and communication are offered by tests, and what styles encourage or discourage such qualities.
What styles of test partitioning are common, and yet scale poorly, are uncohesive and are ineffective at properly expressing the behaviour of a class or component? What styles, tricks and tips can be used to make tests more specification-like and scalable to large codebases? How do we choose between scenario-based and property-based test cases?
Presented at ACCU Oxford (14th September 2015)
Functional C++? As opposed to what — dysfunctional? Well, kind of, yeah. Sure, in C++ the principal unit of composition is called a function, but that doesn't mean it's a functional language. And the idea of restricting mutability of state gets a nod with const, but it's a nod not a hug. And the STL shows influences of functional programming, although it falls short of being compositional. And, yes, sure, C++11 has lambdas, but then again, these days, who doesn't? Lambda calculus was invented in the 1930s.
This talk looks at how to express functional programming ideas in (post)modern C++ in a way that can be considered idiomatic to C++, rather than trying to use the power of overloading and meta-programming to pretend C++ is Haskell or Lisp. In short, immutability beyond const and into shared and persistent data structures, concurrency beyond threading and locks, and thinking about functions as transformations and units of composition rather than actions.
Presented at DevWeek (25th March 2015)
These days, testing is considered a sexy topic for programmers. Who’d have thought it? But what makes for good unit tests (GUTs)? There’s more to effective unit testing than just knowing the assertion syntax of a testing framework.
Testing represents a form of communication and, as such, it offers multiple levels and forms of feedback, not just basic defect detection. Effective unit testing requires an understanding of what forms of feedback and communication are offered by tests, and what styles encourage or discourage such qualities.
What style of test partitioning is most common, and yet scales poorly and is ineffective at properly expressing the behaviour of a class or component? What styles, tricks and tips can be used to make tests more specification-like and can scale as the codebase grows?
This session will address these questions and outline exactly what makes a good unit test.
In this presentation speaker considered theoretical basics of using the redux-saga library, which was created for facilitating the organization of the so-called “side effects” (for example, asynchronous operations). The event participants obtained practical tips on using saga in real-life projects.
This presentation by Igor Nesterenko (Lead Software Engineer, Consultant, GlobalLogic, Kharkiv) was delivered at GlobalLogic Kharkiv JS TechTalk #2 on August 17, 2018.
Асинхронность и многопоточность в Яндекс.Такси — Дмитрий КуриловYandex
Интерактивный сервис должен управлять разнонаправленными потоками данных в реальном времени. При этом важно использовать ресурсы процессора максимально эффективно и минимизировать время доставки сообщения. Рассмотрим эти проблемы и способы их решения на примере разработки Яндекс.Такси.
Async code on kotlin: rx java or/and coroutines - Kotlin Night TurinFabio Collini
It’s never easy to write async code but luckily there are many libraries to manage asynchronicity without adding too much complexity. In the last years RxJava and the other ReactiveX libraries have been very popular but lately there is a new way to manage async code in Kotlin: the coroutines. In this talk we’ll pros and cons of there two approaches and how to leverage them to simplify asynchronous code on Android.
Do they solve the same problem? Can we use them together? Which one can be used to write functional code? How can we use them effectively in Android development?
Spoiler alert: They are both great!
In this talk we’ll see how to solve common problems using RxJava or Coroutines, starting from basic concepts (for example the Retrofit support and how to cancel a task) to some more advanced (like threading, error management and how to combine multiple tasks).
All example of the talk are available on this repository:
https://github.com/fabioCollini/RxJavaVsCoroutines
HKG15-207: Advanced Toolchain Usage Part 3
---------------------------------------------------
Speaker: Ryan Arnold, Maxim Kuvyrkov, Will Newton, Yvan Roux
Date: February 10, 2015
---------------------------------------------------
★ Session Summary ★
This session is a continuation of the Advanced Toolchain Usage Part 1 & 2 presentations given at LCU14. Parts 3 and 4 will cover a variety of topics, such as: Linker tips and tricks, adding symbol versioning interfaces to a system library, debugging the dynamic linker, debugging applications that use malloc, gcc attributes, manually constructing a backtrace on arm & Aarch64, how to add lightweight debugging to your program, how to use a signal handler appropriately, and TLS Models on Aarch64 and when to use them.
--------------------------------------------------
★ Resources ★
Pathable: https://hkg15.pathable.com/meetings/250788
Video: https://www.youtube.com/watch?v=EhNqFCN0YJ0
Etherpad: http://pad.linaro.org/p/hkg15-207
---------------------------------------------------
★ Event Details ★
Linaro Connect Hong Kong 2015 - #HKG15
February 9-13th, 2015
Regal Airport Hotel Hong Kong Airport
---------------------------------------------------
http://www.linaro.org
http://connect.linaro.org
HKG15-211: Advanced Toolchain Usage Part 4
---------------------------------------------------
Speaker: Ryan Arnold, Maxim Kuvyrkov, Will Newton, Yvan Roux
Date: February 10, 2015
---------------------------------------------------
★ Session Summary ★
This session is a continuation of the Advanced Toolchain Usage Part 1 & 2 presentations given at LCU14. Parts 3 and 4 will cover a variety of topics, such as: Linker tips and tricks, adding symbol versioning interfaces to a system library, debugging the dynamic linker, debugging applications that use malloc, gcc attributes, manually constructing a backtrace on arm & Aarch64, how to add lightweight debugging to your program, how to use a signal handler appropriately, and TLS Models on Aarch64 and when to use them.
--------------------------------------------------
★ Resources ★
Pathable: https://hkg15.pathable.com/meetings/250792
Video: https://www.youtube.com/watch?v=9AcklY0Cc7U
Etherpad: http://pad.linaro.org/p/hkg15-211
---------------------------------------------------
★ Event Details ★
Linaro Connect Hong Kong 2015 - #HKG15
February 9-13th, 2015
Regal Airport Hotel Hong Kong Airport
---------------------------------------------------
http://www.linaro.org
Hot Code is Faster Code - Addressing JVM Warm-upMark Price
What is the JVM warm-up problem, and how does it affect our software? How can we aid the runtime in optimising our programs, and is it even a good idea to do so?
This presentation explores the lifecycle of Java code, and how the JVM evolves the runtime representation of code during program execution. From bytecode to assembly and back again (via some uncommon traps), we will cover practical tips on ensuring that Java code is running fast when it matters most.
Beyond php - it's not (just) about the codeWim Godden
Most PHP developers focus on writing code. But creating Web applications is about much more than just wrting PHP. Take a step outside the PHP cocoon and into the big PHP ecosphere to find out how small code changes can make a world of difference on servers and network. This talk is an eye-opener for developers who spend over 80% of their time coding, debugging and testing.
Beyond php - it's not (just) about the codeWim Godden
Most PHP developers focus on writing code. But creating Web applications is about much more than just wrting PHP. Take a step outside the PHP cocoon and into the big PHP ecosphere to find out how small code changes can make a world of difference on servers and network. This talk is an eye-opener for developers who spend over 80% of their time coding, debugging and testing.
Как работает LLVM бэкенд в C#. Егор Богатов ➠ CoreHard Autumn 2019corehard_by
LLVM содержит огромное количество оптимизаций и подходит в качестве бэкенда для многих языков программирования. Но все немного усложняется для Managed языков и JIT сценариев. В этом докладе Егор расскажет о трудностях, с которыми столкнулись в C# при реализации LLVM бэкенда.
What would you do to convince a large audience, who has little context, to use your solution to a problem? One way is to write a design document, which helps scale technical communication and build alignment among stakeholders. The wider the scope of the problem, the more important alignment is. A design document achieves this by addressing three key questions: “what is the goal?”, “how will we achieve it?” and “why are we doing it this way?”. This talk will cover identifying your audience, effectively writing answers to these questions, and involving the right people at the right time.
More engineering organizations than ever are dealing with big data. The long times required to process big datasets slow down development cycles and delay analysis. Apache Beam pipelines distribute processing across many workers, reducing the time it takes to transform large datasets. Creating an effective Beam pipeline requires following best practices and using the specialized data structures Beam introduces. In this talk, I’ll share strategies and lessons learned from scaling Apache Beam pipelines to handle ever-increasing workloads.
Service oriented systems have become hugely popular, and the golden age of the monolith has past. Sometimes these services can be fantastic, and other times not so much. Learning how to evaluate APIs and identify problem areas before jumping head first into development can save teams frustration, time, and money. This session will walk through evaluating an API, best practices, and red flags, all from the standpoint of a developer consuming them. No matter your experience level, you'll leave with the skills to effectively tackle your next API.
This version given at 200ok May 2019
Big, Impossible Projects are exciting, transformative, and begin with an overwhelming number of unanswered questions. Developing against a moving target is never easy — you might find yourself going against best practices such as designing solutions without knowing all the parameters, or encountering dependencies you didn’t even think were possible. Big, Impossible projects can start out looking small and simple, but like an iceberg, they have much more to them once you get up close. In this talk for both new and seasoned leaders you will learn to navigate the icebergs and bring your next Big, Impossible Project to a successful conclusion.
You don't deploy a single microservice. The journey to microservice architecture involves more than how code is written or applications are packaged. It's about creating an interconnected ecosystem that keeps things running. Infrastructure and tools have only grown in importance as microservices have emerged as a dominant architecture pattern. Deploying, scaling, and monitoring are more important for microservices than they ever were before. Attendees will leave this session knowing the basic infrastructure and tooling needs for microservices to be successful.
When I first started talking to people about wanting to work on backend services, the most common reaction was saying that it’s so different from iOS development. I never thought of it that way. Making iOS apps involves a lot of specialized knowledge applied to seemingly specialized problems. However, when those problems are distilled down to their fundamental form, they look similar to problems encountered in other software disciplines. Together we will discover those problems and learn how to apply them to different situations.
First came APIs, then came mobile. Many companies were excited to be able to re-use existing technology to build mobile applications. The quality bar for apps has risen dramatically, and those generic APIs only go so far. Since most apps depend on APIs for data, then shouldn’t those APIs be optimized for mobile experiences? Can a poorly designed API detract from user experience? The answer to both of those questions is yes. This talk will cover why mobile APIs matter, and how existing paradigms and practices can optimize APIs for great mobile experiences.
Generics are one of the features of Swift that set it apart from many other languages. Since Swift debuted, developers have been wondering when to use them and what to use them for. By looking at the standard library, which is the first piece of software to use generics, we can better understand their purpose and utility.
Swift’s design promotes language features like generics and first-class protocols as key architectural components in application development. However, many of the logical patterns that arise, including ones imported from Objective-C, don’t work as we expect them to. In many cases, Swift’s type system resists certain straightforward patterns, such as constraining a property to both a class and a protocol. This talk will highlight several of these challenges, discuss the underlying cause, and evaluate workarounds.
iOS 9 introduced multitasking, which allows apps to be used side by side on certain devices. Along with this came a number of new APIs for handling transitions between different screen configurations. However, integrating these new APIs in an exiting codebase can be trick, and often requires rethinking the way a component is structured. This talk will introduce multitasking, cover the new APIs available to handle different scenarios, and walk through some gotchas when adding support for multitasking into existing applications.
Small is the new big, and for good reason. The benefits of microservices and service-oriented architecture have been extolled for a number of years, yet many forge ahead without thinking of the impact the users of the services. Consuming on micro services can be enjoyable as long as the developer experience has been crafted as finely as the service itself. But just like with any other product, there isn’t a single kind of consumer. Together we will walk through some typical kinds of consumers, what their needs are, and how we can create a great developer experience using brains and tools like Docker.
Every developer has been there--late at night, deadline looming, piling hacks on top of hacks to get a little closer to being finished, there are no tests, edge cases are totally forgotten. Many of us think these situations lead to the worst code we could possibly write. Under such conditions, it is difficult to write robust, well architected code--true--but this is not the only situation that leads to that end. Software development is a complex, creative process that can easily get out of hand. This is because one large factor is often forgotten about--the human factor. Avoiding writing the worst code ultimately comes down to how the people writing, spec'ing, testing, validating, and tracking the code interact.
Gone are the days where making an app just involved writing code. Now, even as a developer, we need to be aware of many other aspects of shipping. They can be human things, like "how do I stop someone from overwriting my changes to the project.pbxproj, storyboard, or xib?" Or technical challenges, like "how do I manage dependencies?” and “why do I always have to do a 3-way merge?” Or even peripheral things like “what happens to our servers if we get featured?” and “what happens to the app when the servers go down?” This session will cover common scaling problems, and solutions to overcome them.
Scaling an app means many things. They can be human things, like "how do I stop someone from overwriting my changes to the project.pbxproj, storyboard, or xib?" Or development things, like "how do I manage dependencies?” and “why do I always have to do a 3-way merge?” Or even peripheral things like “what happens to our servers if we get featured?” and “what happens to the app when the servers go down?” This session will cover common scaling problems, and solutions to overcome them.
We have this new language, Swift, which takes some familiar Apple patterns, and introduces some new ones. With tools like closures and method chaining, there are definitely some new ways to solve the age-old Obj-c architecture challenges. This talk will walk through some of the most common Obj-c design patterns rewritten in Swift, and showcase the strengths and weaknesses of this new language.
Inheriting code is something we all have to deal with, and knowing what you're getting yourself into is a big part of that initial deep dive. Just like anything else, this is a skill that needs to be practiced and perfected over time. This session will walk through some strategies to use when looking at code you didn't write, finding problem spots, as well as share some personal experiences I've had when working with other people's code. You'll leave feeling confident about digging into your next codebase, and have some new tools in your pocket for dealing with the unexpected.
Apps consume a lot of web services these days. Sometimes, these new services can be fantastic, and other times not so much. Learning how to evaluate APIs and identify problem areas before jumping head first into development can save us frustration, time, and money. This session will walk through evaluating an API, best practices, and red flags, all from the standpoint of an iOS dev. No matter your experience level, you'll leave with the skills to effectively tackle your next API.
Providing Globus Services to Users of JASMIN for Environmental Data AnalysisGlobus
JASMIN is the UK’s high-performance data analysis platform for environmental science, operated by STFC on behalf of the UK Natural Environment Research Council (NERC). In addition to its role in hosting the CEDA Archive (NERC’s long-term repository for climate, atmospheric science & Earth observation data in the UK), JASMIN provides a collaborative platform to a community of around 2,000 scientists in the UK and beyond, providing nearly 400 environmental science projects with working space, compute resources and tools to facilitate their work. High-performance data transfer into and out of JASMIN has always been a key feature, with many scientists bringing model outputs from supercomputers elsewhere in the UK, to analyse against observational or other model data in the CEDA Archive. A growing number of JASMIN users are now realising the benefits of using the Globus service to provide reliable and efficient data movement and other tasks in this and other contexts. Further use cases involve long-distance (intercontinental) transfers to and from JASMIN, and collecting results from a mobile atmospheric radar system, pushing data to JASMIN via a lightweight Globus deployment. We provide details of how Globus fits into our current infrastructure, our experience of the recent migration to GCSv5.4, and of our interest in developing use of the wider ecosystem of Globus services for the benefit of our user community.
We describe the deployment and use of Globus Compute for remote computation. This content is aimed at researchers who wish to compute on remote resources using a unified programming interface, as well as system administrators who will deploy and operate Globus Compute services on their research computing infrastructure.
Enhancing Project Management Efficiency_ Leveraging AI Tools like ChatGPT.pdfJay Das
With the advent of artificial intelligence or AI tools, project management processes are undergoing a transformative shift. By using tools like ChatGPT, and Bard organizations can empower their leaders and managers to plan, execute, and monitor projects more effectively.
Large Language Models and the End of ProgrammingMatt Welsh
Talk by Matt Welsh at Craft Conference 2024 on the impact that Large Language Models will have on the future of software development. In this talk, I discuss the ways in which LLMs will impact the software industry, from replacing human software developers with AI, to replacing conventional software with models that perform reasoning, computation, and problem-solving.
Climate Science Flows: Enabling Petabyte-Scale Climate Analysis with the Eart...Globus
The Earth System Grid Federation (ESGF) is a global network of data servers that archives and distributes the planet’s largest collection of Earth system model output for thousands of climate and environmental scientists worldwide. Many of these petabyte-scale data archives are located in proximity to large high-performance computing (HPC) or cloud computing resources, but the primary workflow for data users consists of transferring data, and applying computations on a different system. As a part of the ESGF 2.0 US project (funded by the United States Department of Energy Office of Science), we developed pre-defined data workflows, which can be run on-demand, capable of applying many data reduction and data analysis to the large ESGF data archives, transferring only the resultant analysis (ex. visualizations, smaller data files). In this talk, we will showcase a few of these workflows, highlighting how Globus Flows can be used for petabyte-scale climate analysis.
How Recreation Management Software Can Streamline Your Operations.pptxwottaspaceseo
Recreation management software streamlines operations by automating key tasks such as scheduling, registration, and payment processing, reducing manual workload and errors. It provides centralized management of facilities, classes, and events, ensuring efficient resource allocation and facility usage. The software offers user-friendly online portals for easy access to bookings and program information, enhancing customer experience. Real-time reporting and data analytics deliver insights into attendance and preferences, aiding in strategic decision-making. Additionally, effective communication tools keep participants and staff informed with timely updates. Overall, recreation management software enhances efficiency, improves service delivery, and boosts customer satisfaction.
Navigating the Metaverse: A Journey into Virtual Evolution"Donna Lenk
Join us for an exploration of the Metaverse's evolution, where innovation meets imagination. Discover new dimensions of virtual events, engage with thought-provoking discussions, and witness the transformative power of digital realms."
Developing Distributed High-performance Computing Capabilities of an Open Sci...Globus
COVID-19 had an unprecedented impact on scientific collaboration. The pandemic and its broad response from the scientific community has forged new relationships among public health practitioners, mathematical modelers, and scientific computing specialists, while revealing critical gaps in exploiting advanced computing systems to support urgent decision making. Informed by our team’s work in applying high-performance computing in support of public health decision makers during the COVID-19 pandemic, we present how Globus technologies are enabling the development of an open science platform for robust epidemic analysis, with the goal of collaborative, secure, distributed, on-demand, and fast time-to-solution analyses to support public health.
Globus Compute wth IRI Workflows - GlobusWorld 2024Globus
As part of the DOE Integrated Research Infrastructure (IRI) program, NERSC at Lawrence Berkeley National Lab and ALCF at Argonne National Lab are working closely with General Atomics on accelerating the computing requirements of the DIII-D experiment. As part of the work the team is investigating ways to speedup the time to solution for many different parts of the DIII-D workflow including how they run jobs on HPC systems. One of these routes is looking at Globus Compute as a way to replace the current method for managing tasks and we describe a brief proof of concept showing how Globus Compute could help to schedule jobs and be a tool to connect compute at different facilities.
Enhancing Research Orchestration Capabilities at ORNL.pdfGlobus
Cross-facility research orchestration comes with ever-changing constraints regarding the availability and suitability of various compute and data resources. In short, a flexible data and processing fabric is needed to enable the dynamic redirection of data and compute tasks throughout the lifecycle of an experiment. In this talk, we illustrate how we easily leveraged Globus services to instrument the ACE research testbed at the Oak Ridge Leadership Computing Facility with flexible data and task orchestration capabilities.
Code reviews are vital for ensuring good code quality. They serve as one of our last lines of defense against bugs and subpar code reaching production.
Yet, they often turn into annoying tasks riddled with frustration, hostility, unclear feedback and lack of standards. How can we improve this crucial process?
In this session we will cover:
- The Art of Effective Code Reviews
- Streamlining the Review Process
- Elevating Reviews with Automated Tools
By the end of this presentation, you'll have the knowledge on how to organize and improve your code review proces
Innovating Inference - Remote Triggering of Large Language Models on HPC Clus...Globus
Large Language Models (LLMs) are currently the center of attention in the tech world, particularly for their potential to advance research. In this presentation, we'll explore a straightforward and effective method for quickly initiating inference runs on supercomputers using the vLLM tool with Globus Compute, specifically on the Polaris system at ALCF. We'll begin by briefly discussing the popularity and applications of LLMs in various fields. Following this, we will introduce the vLLM tool, and explain how it integrates with Globus Compute to efficiently manage LLM operations on Polaris. Attendees will learn the practical aspects of setting up and remotely triggering LLMs from local machines, focusing on ease of use and efficiency. This talk is ideal for researchers and practitioners looking to leverage the power of LLMs in their work, offering a clear guide to harnessing supercomputing resources for quick and effective LLM inference.
Gamify Your Mind; The Secret Sauce to Delivering Success, Continuously Improv...Shahin Sheidaei
Games are powerful teaching tools, fostering hands-on engagement and fun. But they require careful consideration to succeed. Join me to explore factors in running and selecting games, ensuring they serve as effective teaching tools. Learn to maintain focus on learning objectives while playing, and how to measure the ROI of gaming in education. Discover strategies for pitching gaming to leadership. This session offers insights, tips, and examples for coaches, team leads, and enterprise leaders seeking to teach from simple to complex concepts.
Exploring Innovations in Data Repository Solutions - Insights from the U.S. G...Globus
The U.S. Geological Survey (USGS) has made substantial investments in meeting evolving scientific, technical, and policy driven demands on storing, managing, and delivering data. As these demands continue to grow in complexity and scale, the USGS must continue to explore innovative solutions to improve its management, curation, sharing, delivering, and preservation approaches for large-scale research data. Supporting these needs, the USGS has partnered with the University of Chicago-Globus to research and develop advanced repository components and workflows leveraging its current investment in Globus. The primary outcome of this partnership includes the development of a prototype enterprise repository, driven by USGS Data Release requirements, through exploration and implementation of the entire suite of the Globus platform offerings, including Globus Flow, Globus Auth, Globus Transfer, and Globus Search. This presentation will provide insights into this research partnership, introduce the unique requirements and challenges being addressed and provide relevant project progress.
Globus Connect Server Deep Dive - GlobusWorld 2024Globus
We explore the Globus Connect Server (GCS) architecture and experiment with advanced configuration options and use cases. This content is targeted at system administrators who are familiar with GCS and currently operate—or are planning to operate—broader deployments at their institution.
AI Pilot Review: The World’s First Virtual Assistant Marketing SuiteGoogle
AI Pilot Review: The World’s First Virtual Assistant Marketing Suite
👉👉 Click Here To Get More Info 👇👇
https://sumonreview.com/ai-pilot-review/
AI Pilot Review: Key Features
✅Deploy AI expert bots in Any Niche With Just A Click
✅With one keyword, generate complete funnels, websites, landing pages, and more.
✅More than 85 AI features are included in the AI pilot.
✅No setup or configuration; use your voice (like Siri) to do whatever you want.
✅You Can Use AI Pilot To Create your version of AI Pilot And Charge People For It…
✅ZERO Manual Work With AI Pilot. Never write, Design, Or Code Again.
✅ZERO Limits On Features Or Usages
✅Use Our AI-powered Traffic To Get Hundreds Of Customers
✅No Complicated Setup: Get Up And Running In 2 Minutes
✅99.99% Up-Time Guaranteed
✅30 Days Money-Back Guarantee
✅ZERO Upfront Cost
See My Other Reviews Article:
(1) TubeTrivia AI Review: https://sumonreview.com/tubetrivia-ai-review
(2) SocioWave Review: https://sumonreview.com/sociowave-review
(3) AI Partner & Profit Review: https://sumonreview.com/ai-partner-profit-review
(4) AI Ebook Suite Review: https://sumonreview.com/ai-ebook-suite-review
Top Features to Include in Your Winzo Clone App for Business Growth (4).pptxrickgrimesss22
Discover the essential features to incorporate in your Winzo clone app to boost business growth, enhance user engagement, and drive revenue. Learn how to create a compelling gaming experience that stands out in the competitive market.
Listen to the keynote address and hear about the latest developments from Rachana Ananthakrishnan and Ian Foster who review the updates to the Globus Platform and Service, and the relevance of Globus to the scientific community as an automation platform to accelerate scientific discovery.
TROUBLESHOOTING 9 TYPES OF OUTOFMEMORYERRORTier1 app
Even though at surface level ‘java.lang.OutOfMemoryError’ appears as one single error; underlyingly there are 9 types of OutOfMemoryError. Each type of OutOfMemoryError has different causes, diagnosis approaches and solutions. This session equips you with the knowledge, tools, and techniques needed to troubleshoot and conquer OutOfMemoryError in all its forms, ensuring smoother, more efficient Java applications.
17. (lldb) p *self.myCar
(Car) $1 = {
NSObject = {
isa = Car
}
_running = NO
_make = 0x000000010077d088 @"Tesla"
_model = 0x000000010077d0a8 @"S"
_year = 2014
_color = 0x00007fd531eb9e30
_gear = Park
}
18. (lldb) po self.myCar
<SwiftCars.Car: 0x7fe8bb456a60>
(lldb) p *self.myCar
error: <EXPR>:1:1: error: '*' is not a prefix unary operator
*self.myCar
^
40. settings set prompt [lldb]$
command alias bd breakpoint disable
command alias be breakpoint enable
command alias bdel breakpoint delete
command alias bcommand breakpoint command add
command alias commands breakpoint command list
58. (lldb) thread return true
error: Error returning from frame 0 of thread 1: We only support
setting simple integer and float return types at present..
100. (lldb) watch set var self.speed
error: "self" is a pointer and . was used to attempt to
access "speed". Did you mean "self->speed"?
(lldb) watch set var self->speed
error: "speed" is not a member of "(Car *const) self"
(lldb) watch set var _speed
101. (lldb) watch set var self.speed
Watchpoint created: Watchpoint 1: addr = 0x6080000a4698 size = 8
state = enabled type = w
declare @ ‘/Projects/SwiftCars/ViewController.swift:28’
watchpoint spec = 'self.speed'
103. (lldb) watch set var _speed
Watchpoint created: Watchpoint 1: addr = 0x7fb9c145d768 size
= 8 state = enabled type = w
watchpoint spec = ‘_speed'
new value: 0
(lldb) watch modify -c '(_speed==15)'
(lldb) c
Process 2150 resuming
Watchpoint 1 hit:
old value: 0
new value: 15
(lldb)
104. (lldb) watch set var self.speed
Watchpoint created: Watchpoint 1: addr = 0x6080000a4698 size = 8
state = enabled type = w
declare @ ‘/Projects/SwiftCars/ViewController.swift:28’
watchpoint spec = 'self.speed'
(lldb) watch modify -c ‘(self.speed==15)’ 1
(lldb) c
Watchpoint 1 hit:
(lldb) po self.speed
6
❌
105. (lldb) watch command add 1
Enter your debugger command(s). Type 'DONE' to end.
> p _speed
> continue
> DONE
(lldb) c
Process 2252 resuming
(NSInteger) $16 = 15
Process 2252 resuming
Command #2 'continue' continued the target.
114. (lldb) help script
Pass an expression to the script interpreter for evaluation and
return the results. Drop into the interactive interpreter if no
expression is given. This command takes 'raw' input (no need to
quote stuff).
Syntax: script [<script-expression-for-evaluation>]
120. find_in_stack = ['-[Car changeGearTo:]']
def continue_ignored(frame, bp_loc, dict):
global find_in_stack
names = set([frame.GetFunctionName() for frame
in frame.GetThread()])
all_ignored = set(find_in_stack)
ignored_here = all_ignored.intersection(names)
if len(ignored_here) == 0:
return False
quit()
find_in_stack = ['-[Car changeGearTo:]']
def continue_ignored(frame, bp_loc, dict):
global find_in_stack
names = set([frame.GetFunctionName() for frame
in frame.GetThread()])
all_ignored = set(find_in_stack)
ignored_here = all_ignored.intersection(names)
if len(ignored_here) == 0:
return False
quit()
121. find_in_stack = ['-[Car changeGearTo:]']
def continue_ignored(frame, bp_loc, dict):
global find_in_stack
names = set([frame.GetFunctionName() for frame
in frame.GetThread()])
all_ignored = set(find_in_stack)
ignored_here = all_ignored.intersection(names)
if len(ignored_here) == 0:
return False
quit()
find_in_stack = ['-[Car changeGearTo:]']
def continue_ignored(frame, bp_loc, dict):
global find_in_stack
names = set([frame.GetFunctionName() for frame
in frame.GetThread()])
all_ignored = set(find_in_stack)
ignored_here = all_ignored.intersection(names)
if len(ignored_here) == 0:
return False
quit()
stack symbol
function declaration
global accessor
all functions in stack
check if symbol we want
is in this stack
if it isn’t, continue
122. find_in_stack = ['-[Car changeGearTo:]']
def continue_ignored(frame, bp_loc, dict):
global find_in_stack
names = set([frame.GetFunctionName() for frame
in frame.GetThread()])
all_ignored = set(find_in_stack)
ignored_here = all_ignored.intersection(names)
if len(ignored_here) == 0:
return False
quit()
125. (lldb) br command add -s python 2
Enter your Python command(s). Type 'DONE' to end.
def function(frame,bp_loc,internal_dict):
"""frame: the SBFrame for the location at which you stopped
bp_loc: an SBBreakpointLocation for the breakpoint
location information
internal_dict: an LLDB support object not to be used"""
global find_in_stack
find_in_stack = ['-[Car changeGearTo:]']
names = set([frame.GetFunctionName() for frame in
frame.GetThread()])
all_ignored = set(find_in_stack)
ignored_here = all_ignored.intersection(names)
if len(ignored_here) == 0:
return False
DONE
135. More Use Cases
• Only break after another breakpoint has
been hit
• Check multiple threads for a symbol
• Data formatters for everything in Objc
• Custom LLDB commands