Case Study: Automated Code Reviews In A Grown SAP Application Landscape At EW...Virtual Forge
Markus Theilen, IT Development coordinator at EWE, talks about his experience and approach to the introduction of Virtual Forge CodeProfiler in the application development of easy+
easy+ is a 100% custom-developed application system of EWE based on SAP ERP 6.0, which includes the components of meter reading, accounting, invoicing and claims management, market communication and reporting / controlling for energy services of the EWE Group.
In this experiential webinar, our guest Mohamed Shaaban will share with you his wide experience in Unit Testing in addition to practical techniques for unit testing your code using C#, NUnit, and Moq.
Case Study: Automated Code Reviews In A Grown SAP Application Landscape At EW...Virtual Forge
Markus Theilen, IT Development coordinator at EWE, talks about his experience and approach to the introduction of Virtual Forge CodeProfiler in the application development of easy+
easy+ is a 100% custom-developed application system of EWE based on SAP ERP 6.0, which includes the components of meter reading, accounting, invoicing and claims management, market communication and reporting / controlling for energy services of the EWE Group.
In this experiential webinar, our guest Mohamed Shaaban will share with you his wide experience in Unit Testing in addition to practical techniques for unit testing your code using C#, NUnit, and Moq.
The core idea of lean is to eliminate/reduce non-value-added activities (termed "wastes") and thus increase customer value. The Agile itself is a lean for the software development life cycle, and I am sharing a couple of Agile best practices adopted by my teams to make the Scrum methodology more extra lean.
The presentation contains the best agile practices and their benefits in terms of Lean in an agile methodologies
The process of changing a software system in such a way that it does not alter the external (observable) behavior of the code yet improves its internal structure, to make it easier to understand and cheaper to modify.
Lightening Talk I gave at Inaka in April 2014.
I was in charge of investigating test-driven development for our iOS mobile team. Since I realized it was such a big concept, after having gathered enough information and having played with it enough, I decided to introduce my fellows on the topic by presenting it in a formal talk with slides. The aim was teaching them a different way of developing, which, for us, at that moment, was completely new and controversial.
We investigate one of the most popular approaches to creating software: test driven development. From the basic understanding why tests are important to a new software development paradigm, where you start with tests and them do the implementation. We glance over different areas of testing and see how one should really do the software testing in different situation.
Improve your development skills with Test Driven DevelopmentJohn Stevenson
A talk at the Graduate Developer community on test driven development. Helping students and graduates understand the point of a test first approach, demonstrate the tools and show how easy it is to start.
An introduction to unit testing using Visual Studio, C#, xUnit.net, and Moq. What it is, what is isn't, why we don't do it, how to design for testability, what to test, test driven development, unit testing frameworks, mocking libraries, how to get started.
Feature toggle widely used in industry to release incomplete features and do A/B testing on features. The presentation covers pros and cons of the approach and share some tips and tricks.
Improving The Quality of Existing SoftwareSteven Smith
Presented at DevReach 2013.
As developers, most of our time is spent working on existing software. Sure, occasionally we get the chance to fire up a new Solution in Visual Studio, and that can be exciting. But after the first day, we find ourselves once more having to deal with the work we did yesterday. And today, we know more than we did yesterday, so there are things we’d do differently, if we had it to do over.
Over time, software rots. If we’re not diligent, our beautiful code can degrade into a worthless mess. Keeping our code in working condition is no different than changing the oil in our car – it’s preventive maintenance. In this session, Steve will look at some common places to look for signs of degradation in existing applications, and steps to take to improve the code. Examples will use C# and primarily ASP.NET.
The core idea of lean is to eliminate/reduce non-value-added activities (termed "wastes") and thus increase customer value. The Agile itself is a lean for the software development life cycle, and I am sharing a couple of Agile best practices adopted by my teams to make the Scrum methodology more extra lean.
The presentation contains the best agile practices and their benefits in terms of Lean in an agile methodologies
The process of changing a software system in such a way that it does not alter the external (observable) behavior of the code yet improves its internal structure, to make it easier to understand and cheaper to modify.
Lightening Talk I gave at Inaka in April 2014.
I was in charge of investigating test-driven development for our iOS mobile team. Since I realized it was such a big concept, after having gathered enough information and having played with it enough, I decided to introduce my fellows on the topic by presenting it in a formal talk with slides. The aim was teaching them a different way of developing, which, for us, at that moment, was completely new and controversial.
We investigate one of the most popular approaches to creating software: test driven development. From the basic understanding why tests are important to a new software development paradigm, where you start with tests and them do the implementation. We glance over different areas of testing and see how one should really do the software testing in different situation.
Improve your development skills with Test Driven DevelopmentJohn Stevenson
A talk at the Graduate Developer community on test driven development. Helping students and graduates understand the point of a test first approach, demonstrate the tools and show how easy it is to start.
An introduction to unit testing using Visual Studio, C#, xUnit.net, and Moq. What it is, what is isn't, why we don't do it, how to design for testability, what to test, test driven development, unit testing frameworks, mocking libraries, how to get started.
Feature toggle widely used in industry to release incomplete features and do A/B testing on features. The presentation covers pros and cons of the approach and share some tips and tricks.
Improving The Quality of Existing SoftwareSteven Smith
Presented at DevReach 2013.
As developers, most of our time is spent working on existing software. Sure, occasionally we get the chance to fire up a new Solution in Visual Studio, and that can be exciting. But after the first day, we find ourselves once more having to deal with the work we did yesterday. And today, we know more than we did yesterday, so there are things we’d do differently, if we had it to do over.
Over time, software rots. If we’re not diligent, our beautiful code can degrade into a worthless mess. Keeping our code in working condition is no different than changing the oil in our car – it’s preventive maintenance. In this session, Steve will look at some common places to look for signs of degradation in existing applications, and steps to take to improve the code. Examples will use C# and primarily ASP.NET.
Improving the Quality of Existing SoftwareSteven Smith
Given at DogFoodCon 2016 in Columbus, Ohio
As developers, most of our time is spent working on existing software – even if it’s just the software we wrote ourselves, yesterday. And over time, software rots. If were not diligent, our beautiful code can degrade into a worthless mess. Keeping our code in working condition is no different than changing the oil in our car “ its preventive maintenance. In this session, Steve will cover some common places to look for signs of degradation in existing applications, and describe the steps we can take to improve our code. Examples will use C# and primarily ASP.NET.
Feature toggling is a multi-purpose technique for easily turning features on and off. I will describe the concept, different types of feature toggles, some best practices, and give some examples of how Visma currently uses feature toggling.
Improving the Design of Existing SoftwareSteven Smith
Combat technical debt and keep your code maintainable using these principles, heuristics, and refactoring techniques. Presented October 2017 at DogfoodCon in Columbus, OH. Learn more at http://bit.ly/PS-Refactoring
One of the main hindrances to teams being able to respond rapidly to new features are technical problems resulting from bad coding practices, also known as technical debt. Melissa and Brett will cover Agile tools and practices that help development teams write better code and increase maintainability. Topics that will be covered include:
Pair programming
Automated Unit Testing
Refactoring
Test-Driven Development
Agile Architecture
Droidcon Spain 2016 - The Pragmatic Android Programmer: from hype to realityDaniel Gallego Vico
This presentation shows how to be a pragmatic Android programmer by showing real examples of applications/products developed in BQ attending to three important topics:
- Why and how to implement a pragmatic CLEAN architecture with a custom dependency injection framework and ReactiveX features.
- Why and how to implement unit, integration, view and smoke tests in every CLEAN layer and what tools should be used.
- Why and how to implement pragmatic Continuous
Development/Testing/Integration/Delivery by showing several tricks, plugins and snippets that you could use as a daily basis.
PHPConf.asia 2016 - BDD with Behat for BeginnersAdam Englander
Learn the basics of Behavioral Driven Development (BDD) with Behat to build quality applications. Behat utilizes natural language syntax to define feature test scenarios. In this tutorial you will learn how to write integration tests for web applications. This will include utilizing Selenium WebDriver for real world multi-browser testing including introductions to Selenium Grid and Sauce Labs. Learn a better way to perform integration testing today!
Release software is no less important than activities that precede it.
The Continuous Delivery is a set of practices and methodologies that build an ecosystem for the software development lifecycle.
We will see how to build this ecosystem around the applications developed, for which this release activities becomes a low-risk, inexpensive, fast and predictable.
Improving the Quality of Existing SoftwareSteven Smith
How do you improve the quality of your existing software, while continuing to add value for your customers? What are some heuristics and code smells you can look for, and principles and patterns you can use to guide you, as you make your software better over time instead of worse?
Code we've written once has to be kept readable, maintainable, understandable and extensible for many years. Good code is not self-serving but the foundation for working together.
Refactoring can help you to keep the quality of the relevant parts of our systems high.
The technique is really easy (almost too easy) - improve the naming, structure, and responsibility in small steps that don't change behavior and run your tests after each step.
18 years ago I got hooked on Refactoring when Martin Fowler's first book came out. I've been using it since then on a daily basis on many different projects. Since then a lot has changed, especially with the help of modern IDEs with their automated refactorings and intentions.
Now he asked me to help review the 2nd edition. Our discussions reminded me that each generation of developers should be taught this crucial skill. That's why I want to give an overview of core refactorings and code-smells but also demonstrate the tips and tricks of today's tools that make this task so much easier.
Plus a sneak preview of the upcoming book.
Software Engineering, Software Consulting, Tech Lead.
Spring Boot, Spring Cloud, Spring Core, Spring JDBC, Spring Security,
Spring Transaction, Spring MVC,
Log4j, REST/SOAP WEB-SERVICES.
Accelerate Enterprise Software Engineering with PlatformlessWSO2
Key takeaways:
Challenges of building platforms and the benefits of platformless.
Key principles of platformless, including API-first, cloud-native middleware, platform engineering, and developer experience.
How Choreo enables the platformless experience.
How key concepts like application architecture, domain-driven design, zero trust, and cell-based architecture are inherently a part of Choreo.
Demo of an end-to-end app built and deployed on Choreo.
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.
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.
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.
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.
May Marketo Masterclass, London MUG May 22 2024.pdfAdele Miller
Can't make Adobe Summit in Vegas? No sweat because the EMEA Marketo Engage Champions are coming to London to share their Summit sessions, insights and more!
This is a MUG with a twist you don't want to miss.
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.
Check out the webinar slides to learn more about how XfilesPro transforms Salesforce document management by leveraging its world-class applications. For more details, please connect with sales@xfilespro.com
If you want to watch the on-demand webinar, please click here: https://www.xfilespro.com/webinars/salesforce-document-management-2-0-smarter-faster-better/
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.
Unleash Unlimited Potential with One-Time Purchase
BoxLang is more than just a language; it's a community. By choosing a Visionary License, you're not just investing in your success, you're actively contributing to the ongoing development and support of BoxLang.
First Steps with Globus Compute Multi-User EndpointsGlobus
In this presentation we will share our experiences around getting started with the Globus Compute multi-user endpoint. Working with the Pharmacology group at the University of Auckland, we have previously written an application using Globus Compute that can offload computationally expensive steps in the researcher's workflows, which they wish to manage from their familiar Windows environments, onto the NeSI (New Zealand eScience Infrastructure) cluster. Some of the challenges we have encountered were that each researcher had to set up and manage their own single-user globus compute endpoint and that the workloads had varying resource requirements (CPUs, memory and wall time) between different runs. We hope that the multi-user endpoint will help to address these challenges and share an update on our progress here.
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.
Understanding Globus Data Transfers with NetSageGlobus
NetSage is an open privacy-aware network measurement, analysis, and visualization service designed to help end-users visualize and reason about large data transfers. NetSage traditionally has used a combination of passive measurements, including SNMP and flow data, as well as active measurements, mainly perfSONAR, to provide longitudinal network performance data visualization. It has been deployed by dozens of networks world wide, and is supported domestically by the Engagement and Performance Operations Center (EPOC), NSF #2328479. We have recently expanded the NetSage data sources to include logs for Globus data transfers, following the same privacy-preserving approach as for Flow data. Using the logs for the Texas Advanced Computing Center (TACC) as an example, this talk will walk through several different example use cases that NetSage can answer, including: Who is using Globus to share data with my institution, and what kind of performance are they able to achieve? How many transfers has Globus supported for us? Which sites are we sharing the most data with, and how is that changing over time? How is my site using Globus to move data internally, and what kind of performance do we see for those transfers? What percentage of data transfers at my institution used Globus, and how did the overall data transfer performance compare to the Globus users?
OpenFOAM solver for Helmholtz equation, helmholtzFoam / helmholtzBubbleFoamtakuyayamamoto1800
In this slide, we show the simulation example and the way to compile this solver.
In this solver, the Helmholtz equation can be solved by helmholtzFoam. Also, the Helmholtz equation with uniformly dispersed bubbles can be simulated by helmholtzBubbleFoam.
2. What is refactoring?
• An individual Refactoring is a software change:
To make it easier to understand
To make it cheaper to modify
Without changing its observable behavior
• It’s based on a self-checking suite of test (<1 minute)
• = ∑ small steps
• Start Run Test Run Test Run Test
Note: Changes are Committed after every green status
Step a
Few minutes
Step b
Few minutes
Step c
Few minutes
Step b again
Few minutes
4. When to refactor?
• Best time is just before I need to “touch” it (after investing some
time trying to understand it)
• Add a new feature
• Fix a bug
• In a code review
• Several aims:
• Comprehension refactoring
• Preparatory refactoring
A B
5. When NOT to refactor?
• It’s easier to rewrite it
• When I don´t need to modify it
• In case I found a large refactoring vs small new
feature. It depends, there is a tradeoff. I certainly
refactor:
• If it makes my new feature easier to implement
• If this is a code I visit frequently
6. What do I tell my manager?
• Don´t try to justify with moral reasons: “Clean code”, “Good
programming practice”, …
• Don´t schedule weeks of pure refactoring
I don´t put time on my plans to do refactoring. Most refactoring
happens while I’m adding features or fixing bugs
• Depends on your manager. Is he a techy manager?
• Yes Isn’t hard to justify.
• No Just don´t tell.
7. How do I get a solid test suite?
• It’s risk driven activity:
• Don´t test every public method.
• 100% coverage ≠ test suite quality
• Write tests to try to find bugs (now or in the future).
• Write test in areas that I´m worried about going wrong.
• Write tests for all the things should do, and for any condition that might cause the class to
fail
• First happy path, and then test at boundaries.
• Write test (on your contracts / APIs), so they don´t depend on your
implementation details.
• Otherwise I can spend more time changing the tests than the code under test
8. FAQ:
• Software Limits (API)
• Databases
• Feature branches
• Legacy code. See Book “Working Effectively with Legacy Code” from
Michael Feathers
• Architecture: Simple design / Incremental design / YAGNI
/Evolutionary architecture
9. The most useful to learn first
Refactorings Before After
Extract/Inline Function Lines of code [intention is not clear] f()
Extract/Inline Variable Expression: a * b + c const product = a*b
Change Function Declaration f(a,b) newName(a,b) or f(a) or f(a,b,c)
Encapsulate Variable alpha=23 setAlpha(a)
alpha()
Introduce Parameter Object f(min,max) range = new Range(min,max)
f(range)
Combine Functions into Class f1(), f2(), … Class X{ f1() f2() }
Combine Functions into
Transform
calculateBase(aReading)
calculateCharge(aReading)
enrichReading(original) {
const result= _.cloneDeep(original)
result.base=calculateBase(result)
result.charge=calculateCharge(result)
Split Phase Long Function f() f(){
priceOrder()
calculateShipping() }
Refactoring List I:
Note: Red ones are the opposite
10. Encapsulation Moving Features Organising Data
Encapsulate Record Move Function Split Variable
Encapsulate Collection Move Field Rename Field
Replace primitive with
Object
Move Statements into Functions
Move Statements to Callers
Replace derived variable with Query
Replace temp with Query Replace Inline code with existing
function call
Change Reference to Value
Change Value to Reference
Extract / Inline Class Slide statements
Hide Delegate
Remove Middle Man
Split loop
Substitute algorithm Replace loop with pipeline
Remove dead code
Hide secrets (data structures). Mainly for mutable data
Modularity: Only understand a small part to make a change
Data Structure are the key to understand what’s going on
Refactoring List II:
11. Simplifying conditional logic Refactoring APIs Dealing with Inheritance
Decompose conditional Separate Query from modifier Pull up / Push down method
Consolidate conditional
expression
Parameterize function Pull up / Push down field
Replace nested conditional with
guard clauses
Remove flag argument Pull up constructor body
Replace contional with
Polymorphism
Preserve Whole Object Replace type code with subclasses
Remove subclass
Introduce special case Replace Parameter with query
Replace Query with Parameter
Extract Superclass
Introduce Assertion Remove Setting method Collapse Hierarchy
Replace constructor with Factory function Replace subclass with delegate
Replace Function with Command Object
Replace command object with function
Replace superclass with delegate
Much of the complexity of programs lies in conditional logic
APIs are the module joints. Make it easy to understand / use
Inheritance can only be played once
Refactoring List III:
12.
13. • And now let’s go on with the kata:
martinsson/BugsZero-Kata
Editor's Notes
Any fool can write code that a computer can understand. Good programmers write code that humans can understand
Modify = Add new features / fix bugs
No new functionality, no new tests
Ej: When Refactoring don´t think about performance optimization
In a code review pair programming is recommended
API Rename
Mark old function as deprecated, pass-through to the new one.
Database:
Use data migration scripts & versioning
Refactoring are separated over several consecutive production releases
Branches
Feature branches last < 1 day (CI)
Break large features into smaller chunks
Use Feature flags
Merges: The larger the feature branch, the more complicated
Merges: The larger the feature branch, the less refactoring (as merges are more complicated)
Legacy code:
Refactoring can be a fantastic tool to understand it. But there is a common lack of tests.
Refactor step by step, not all at once
Refactor more in areas you visit frequently
Architecture:
Architecture before coding. And put flexibility mechanism into SW Slow down my ability to react to change
Build SW that solves ONLY the currently understood needs. As my understanding changes I use Refactoring to adapt to those new demands.