A (very) opinionated guide to MSBuild and Project FilesDavid Wengier
This document discusses project files and MSBuild. It explains that project files are MSBuild files that define properties, items, imports and targets. It compares legacy project files to SDK-style project files. It also discusses how MSBuild works by parsing the project file and evaluating properties, items, imports and targets. Finally, it recommends using build logging to see how MSBuild evaluates the project file.
This document provides an overview of building NativeScript applications with Angular. It covers setting up a NativeScript project with Angular, using components and bindings, routing, forms, HTTP requests, and testing. While there are some minor differences from web Angular, NativeScript aims to embrace the Angular framework and allow building truly native mobile apps using Angular concepts.
This document discusses the history of asynchronous programming and how reactive programming with RxJS addresses limitations of previous approaches. It covers callback hell with nested callbacks, promises, and async/await. RxJS introduces Observables that allow streaming and combining of asynchronous data over time. The document demonstrates building basic Observable and Observer classes as well as an operator. Reactive programming with RxJS makes asynchronous code more readable and addresses issues like cancellation and error handling.
Firebase and ng2
This document discusses Firebase and AngularFire/AngularFire2. It summarizes that Firebase is a backend as a service that provides realtime database functionality. AngularFire/AngularFire2 are wrappers that make the Firebase API accessible to Angular applications. Key features covered include authentication, authorization, data validation, and working with data through observable references and promises. Best practices like shallow data structures and avoiding deep nesting are also highlighted.
s React.js a library or a framework? In any case, it is a new way of working that represents a revolution in the way of building web projects. It has very particular characteristics that allow us, for instance, to render React code from the server side, or to include React components from Twig tags. During this talk we will present React.js, we will explore how to take advantage of it from PHP projects and we will give answers to practical problems such as universal (isomorphical) rendering and the generation of React.js forms from Symfony forms without duplication of efforts.
[AngularJS] From Angular to Mobile in 30 minutesGlobant
AngularJS is a toolset for building web application frameworks. It allows developers to create controllers and views, bind data to HTML, and communicate with servers. The document discusses AngularJS concepts like $scope, controllers, dependency injection and shows an example of building a TODO list app with AngularJS. Key features highlighted include data binding, directives, forms, localization and more.
Паразитируем на React-экосистеме (Angular 4+) / Алексей Охрименко (IPONWEB)Ontico
The document discusses how Angular components can "parasitize" the React ecosystem. It begins by providing code examples of basic Angular component creation. It then explores terminology related to parasitism and parasitoids. Various approaches for communicating between Angular components using services, properties, and Redux are presented. The document also discusses ideas for libraries that could help convert React components to Angular. It covers tools and patterns for state management in Angular like Redux and MobX. Finally, it discusses how Angular components could potentially "parasitize" the React ecosystem in both helpful and harmful ways.
A (very) opinionated guide to MSBuild and Project FilesDavid Wengier
This document discusses project files and MSBuild. It explains that project files are MSBuild files that define properties, items, imports and targets. It compares legacy project files to SDK-style project files. It also discusses how MSBuild works by parsing the project file and evaluating properties, items, imports and targets. Finally, it recommends using build logging to see how MSBuild evaluates the project file.
This document provides an overview of building NativeScript applications with Angular. It covers setting up a NativeScript project with Angular, using components and bindings, routing, forms, HTTP requests, and testing. While there are some minor differences from web Angular, NativeScript aims to embrace the Angular framework and allow building truly native mobile apps using Angular concepts.
This document discusses the history of asynchronous programming and how reactive programming with RxJS addresses limitations of previous approaches. It covers callback hell with nested callbacks, promises, and async/await. RxJS introduces Observables that allow streaming and combining of asynchronous data over time. The document demonstrates building basic Observable and Observer classes as well as an operator. Reactive programming with RxJS makes asynchronous code more readable and addresses issues like cancellation and error handling.
Firebase and ng2
This document discusses Firebase and AngularFire/AngularFire2. It summarizes that Firebase is a backend as a service that provides realtime database functionality. AngularFire/AngularFire2 are wrappers that make the Firebase API accessible to Angular applications. Key features covered include authentication, authorization, data validation, and working with data through observable references and promises. Best practices like shallow data structures and avoiding deep nesting are also highlighted.
s React.js a library or a framework? In any case, it is a new way of working that represents a revolution in the way of building web projects. It has very particular characteristics that allow us, for instance, to render React code from the server side, or to include React components from Twig tags. During this talk we will present React.js, we will explore how to take advantage of it from PHP projects and we will give answers to practical problems such as universal (isomorphical) rendering and the generation of React.js forms from Symfony forms without duplication of efforts.
[AngularJS] From Angular to Mobile in 30 minutesGlobant
AngularJS is a toolset for building web application frameworks. It allows developers to create controllers and views, bind data to HTML, and communicate with servers. The document discusses AngularJS concepts like $scope, controllers, dependency injection and shows an example of building a TODO list app with AngularJS. Key features highlighted include data binding, directives, forms, localization and more.
Паразитируем на React-экосистеме (Angular 4+) / Алексей Охрименко (IPONWEB)Ontico
The document discusses how Angular components can "parasitize" the React ecosystem. It begins by providing code examples of basic Angular component creation. It then explores terminology related to parasitism and parasitoids. Various approaches for communicating between Angular components using services, properties, and Redux are presented. The document also discusses ideas for libraries that could help convert React components to Angular. It covers tools and patterns for state management in Angular like Redux and MobX. Finally, it discusses how Angular components could potentially "parasitize" the React ecosystem in both helpful and harmful ways.
This is a presentation given by Dirk-Jan Rutten and Florentijn Hogerwerf at the React-Amsterdam Winter Event held on the 23rd of February 2017 (https://www.meetup.com/React-Amsterdam/events/237423993/).
This document provides an overview of event sourcing and CQRS approaches to system architecture. It discusses command handling, view handling, and writing event sourced DDD systems. It provides code examples of modeling commands, events, and aggregates in an event sourced system. It discusses benefits of event sourcing like having an audit log, horizontal scaling, and using events to power other services.
Zepto.js, a jQuery-compatible mobile JavaScript framework in 2KThomas Fuchs
The document discusses the goals and design of Zepto.js, a JavaScript framework for mobile web applications. It aims to have a very small codebase that is easy to use, extends native browser APIs, and avoids non-essential browser implementations. It provides a jQuery-like API but takes advantage of mobile features for better performance on small screens and devices with limited bandwidth.
The document provides an overview and introduction to jQuery selectors and DOM manipulation. It discusses 20 different types of jQuery selectors including selecting by id, class, tag name and attributes. It also covers DOM traversal methods like children(), parents() and filtering methods like filter(). The document aims to explain how to select and manipulate elements on a web page using jQuery.
In this talk I demonstrated how easy Dojo is integrating into the Adobe AIR runtime. Using a performance analysis tool I demonstrated how to use charting, grids and other features of Adobe AIR and the Dojo Toolkit
The document discusses craftsmanship in software development. It provides examples of Wozniak's meticulous and perfectionist approach to engineering when designing Apple hardware and software. It also discusses different stages of craftsmanship like apprentice, journeyman, and master, and how these relate to becoming better at software development through continually learning, building, and improving skills. The emphasis is on cultivating high standards of quality and care in one's work.
The document discusses ES6 patterns used in Redux code. It explains how Redux uses functional programming patterns like higher-order functions, pure functions, and immutable data structures. Specifically, it analyzes code from Redux that uses arrow functions, rest/spread syntax, and avoids mutations to create middleware and handle state updates immutably. Reading wild code helps improve the skill of code comprehension and builds intuition about how to apply new patterns.
Basic Tutorial of React for ProgrammersDavid Rodenas
This is the support of a course to teach React programming for Java and C# programmers. It covers from its origins in Facebook til separation of presentational and container components. What is JSX, rules, state, props, refactoring, conditionals, repeats, forms, synchronizing values, composition, and so on.
This document provides information about using the Google API Perl client library. It discusses authentication with OAuth2 and making API calls to various Google services like Calendar, Plus, URL Shortener, and WebFonts. Code examples are provided for accessing Calendar APIs to list, create, update and delete events using the client library.
This document provides instructions for a test-driven development (TDD) coding assignment using JavaScript. It outlines how to set up the development environment, run tests, and iterate through solving tests one by one while committing changes. It also includes an introduction to JavaScript basics like types, functions, classes, and interfaces to provide context for completing the assignment. Students are instructed to work individually on solving commented tests in a GitHub classroom repository by running tests and committing after each solved test.
TDC2017 | São Paulo - Trilha Java EE How we figured out we had a SRE team at ...tdc-globalcode
This document discusses how to build APIs productively using Spring Boot, Spring MVC, and Spring Data. It covers how Spring Boot helps with dependency management, embedded servlet containers, and auto-configuration. Spring MVC is described as providing simplicity in API exposure and serialization/deserialization. Spring Data provides standard repository implementations and abstraction for data access across different data sources, including support for caching.
Redux saga: managing your side effects. Also: generators in es6Ignacio Martín
The document summarizes a presentation on Redux Sagas given at a React Native meetup in Munich in May 2017. It introduces generators and how they enable asynchronous logic to be written in a synchronous style. It provides examples of using generators to increment a value each time a new value is passed in and shows how generators can be used in a loop. The purpose of Redux Sagas is to manage asynchronous side effects in Redux applications using generator functions.
The document provides an overview of a presentation about adopting F# for C#/OOP developers. It discusses:
- Why F# was chosen, including better tooling support and community growth.
- Some advantages of F# compared to C#, like recursive modules, better code style and purity.
- Challenges in adopting F#, like different programming paradigms and culture between OOP and FP.
- Examples showing F# code that is more concise and readable compared to equivalent C# code.
Typescript fundamentals document summarized in 3 sentences:
The document discusses Typescript fundamentals including types, classes, interfaces, modules and how to use the Typescript compiler. It explains how Typescript adds type safety and compile time checking to JavaScript by using types for variables, parameters, returns and more. Examples are provided for many Typescript features and how they compile down to equivalent JavaScript.
This document provides an overview of React and Redux concepts including:
- React basics like components, props, state, and lifecycle methods
- Flux architecture and how data flows through actions, dispatcher, and stores
- Redux as an alternative to Flux that uses a single store updated by reducers in response to actions
- Additional React topics like JSX, propTypes, and using React with ES6 classes are also covered.
The document summarizes the New York Times' open source Store library for Android, which provides a unified way to fetch, parse, cache, and retrieve data in Android applications. The Store abstracts these processes and enforces unidirectional data flow while exposing data as RxJava Observables. Key aspects include using StoreBuilders to configure Stores, adding fetchers and parsers, using middleware like GsonSourceParser, and enabling disk caching. The document also provides guidance on open sourcing a new library, including using Android Studio and GitHub to set up the project, adding documentation like README and license, and publishing to Maven Central.
The document discusses the components and utilities of the Backbone.js framework. It describes the key components of Backbone - Models, Collections, Views - and how they work together. Models contain interactive data and bind attributes to the DOM. Collections provide methods to manage ordered sets of models. Views handle templating and user interactions. The document also covers utilities like routing and events that help connect components.
The Ring programming language version 1.9 book - Part 54 of 210Mahmoud Samir Fayed
This document discusses using the RingLibCurl library in Ring to make HTTP requests. It provides examples of making GET and POST requests, using cURL to log into Facebook, saving the output of a request to a string, and retrieving stock data from Yahoo Finance by extracting cookie and crumb values. The examples demonstrate initializing cURL handles, setting options like the URL, headers, and cookies, performing requests, and cleaning up handles after requests are completed.
Here are the steps to move the frontend out of the Main class and into its own thread:
1. Create a Frontend class that extends AbstractHandler and implements Runnable
2. Move the frontend handling logic from Main into the run() method of Frontend
3. Add a handleCount field to Frontend of type AtomicInteger
4. In the run() method, periodically log the value of handleCount every 5 seconds
5. In the handle() method, increment handleCount using getAndIncrement() after generating the page
6. From Main, instantiate a Frontend object and call start() on its thread to run asynchronously
This will separate the frontend into its own thread of execution. The handleCount field
OBJECTS IN Object Oriented Programming .pptSaadAsim11
An object is an instance of a class that has an identity, state, and behavior. The identity is defined by the object's name, state represents the data values of its attributes, and behavior is represented by the functions defined in its class. Objects can be created by declaring a variable of a class type, which allocates memory for the object. Objects can be passed as arguments to functions by value, making a copy, or by reference, where changes made inside the function affect the actual object. A method can return an object as the return value.
This is a presentation given by Dirk-Jan Rutten and Florentijn Hogerwerf at the React-Amsterdam Winter Event held on the 23rd of February 2017 (https://www.meetup.com/React-Amsterdam/events/237423993/).
This document provides an overview of event sourcing and CQRS approaches to system architecture. It discusses command handling, view handling, and writing event sourced DDD systems. It provides code examples of modeling commands, events, and aggregates in an event sourced system. It discusses benefits of event sourcing like having an audit log, horizontal scaling, and using events to power other services.
Zepto.js, a jQuery-compatible mobile JavaScript framework in 2KThomas Fuchs
The document discusses the goals and design of Zepto.js, a JavaScript framework for mobile web applications. It aims to have a very small codebase that is easy to use, extends native browser APIs, and avoids non-essential browser implementations. It provides a jQuery-like API but takes advantage of mobile features for better performance on small screens and devices with limited bandwidth.
The document provides an overview and introduction to jQuery selectors and DOM manipulation. It discusses 20 different types of jQuery selectors including selecting by id, class, tag name and attributes. It also covers DOM traversal methods like children(), parents() and filtering methods like filter(). The document aims to explain how to select and manipulate elements on a web page using jQuery.
In this talk I demonstrated how easy Dojo is integrating into the Adobe AIR runtime. Using a performance analysis tool I demonstrated how to use charting, grids and other features of Adobe AIR and the Dojo Toolkit
The document discusses craftsmanship in software development. It provides examples of Wozniak's meticulous and perfectionist approach to engineering when designing Apple hardware and software. It also discusses different stages of craftsmanship like apprentice, journeyman, and master, and how these relate to becoming better at software development through continually learning, building, and improving skills. The emphasis is on cultivating high standards of quality and care in one's work.
The document discusses ES6 patterns used in Redux code. It explains how Redux uses functional programming patterns like higher-order functions, pure functions, and immutable data structures. Specifically, it analyzes code from Redux that uses arrow functions, rest/spread syntax, and avoids mutations to create middleware and handle state updates immutably. Reading wild code helps improve the skill of code comprehension and builds intuition about how to apply new patterns.
Basic Tutorial of React for ProgrammersDavid Rodenas
This is the support of a course to teach React programming for Java and C# programmers. It covers from its origins in Facebook til separation of presentational and container components. What is JSX, rules, state, props, refactoring, conditionals, repeats, forms, synchronizing values, composition, and so on.
This document provides information about using the Google API Perl client library. It discusses authentication with OAuth2 and making API calls to various Google services like Calendar, Plus, URL Shortener, and WebFonts. Code examples are provided for accessing Calendar APIs to list, create, update and delete events using the client library.
This document provides instructions for a test-driven development (TDD) coding assignment using JavaScript. It outlines how to set up the development environment, run tests, and iterate through solving tests one by one while committing changes. It also includes an introduction to JavaScript basics like types, functions, classes, and interfaces to provide context for completing the assignment. Students are instructed to work individually on solving commented tests in a GitHub classroom repository by running tests and committing after each solved test.
TDC2017 | São Paulo - Trilha Java EE How we figured out we had a SRE team at ...tdc-globalcode
This document discusses how to build APIs productively using Spring Boot, Spring MVC, and Spring Data. It covers how Spring Boot helps with dependency management, embedded servlet containers, and auto-configuration. Spring MVC is described as providing simplicity in API exposure and serialization/deserialization. Spring Data provides standard repository implementations and abstraction for data access across different data sources, including support for caching.
Redux saga: managing your side effects. Also: generators in es6Ignacio Martín
The document summarizes a presentation on Redux Sagas given at a React Native meetup in Munich in May 2017. It introduces generators and how they enable asynchronous logic to be written in a synchronous style. It provides examples of using generators to increment a value each time a new value is passed in and shows how generators can be used in a loop. The purpose of Redux Sagas is to manage asynchronous side effects in Redux applications using generator functions.
The document provides an overview of a presentation about adopting F# for C#/OOP developers. It discusses:
- Why F# was chosen, including better tooling support and community growth.
- Some advantages of F# compared to C#, like recursive modules, better code style and purity.
- Challenges in adopting F#, like different programming paradigms and culture between OOP and FP.
- Examples showing F# code that is more concise and readable compared to equivalent C# code.
Typescript fundamentals document summarized in 3 sentences:
The document discusses Typescript fundamentals including types, classes, interfaces, modules and how to use the Typescript compiler. It explains how Typescript adds type safety and compile time checking to JavaScript by using types for variables, parameters, returns and more. Examples are provided for many Typescript features and how they compile down to equivalent JavaScript.
This document provides an overview of React and Redux concepts including:
- React basics like components, props, state, and lifecycle methods
- Flux architecture and how data flows through actions, dispatcher, and stores
- Redux as an alternative to Flux that uses a single store updated by reducers in response to actions
- Additional React topics like JSX, propTypes, and using React with ES6 classes are also covered.
The document summarizes the New York Times' open source Store library for Android, which provides a unified way to fetch, parse, cache, and retrieve data in Android applications. The Store abstracts these processes and enforces unidirectional data flow while exposing data as RxJava Observables. Key aspects include using StoreBuilders to configure Stores, adding fetchers and parsers, using middleware like GsonSourceParser, and enabling disk caching. The document also provides guidance on open sourcing a new library, including using Android Studio and GitHub to set up the project, adding documentation like README and license, and publishing to Maven Central.
The document discusses the components and utilities of the Backbone.js framework. It describes the key components of Backbone - Models, Collections, Views - and how they work together. Models contain interactive data and bind attributes to the DOM. Collections provide methods to manage ordered sets of models. Views handle templating and user interactions. The document also covers utilities like routing and events that help connect components.
The Ring programming language version 1.9 book - Part 54 of 210Mahmoud Samir Fayed
This document discusses using the RingLibCurl library in Ring to make HTTP requests. It provides examples of making GET and POST requests, using cURL to log into Facebook, saving the output of a request to a string, and retrieving stock data from Yahoo Finance by extracting cookie and crumb values. The examples demonstrate initializing cURL handles, setting options like the URL, headers, and cookies, performing requests, and cleaning up handles after requests are completed.
Here are the steps to move the frontend out of the Main class and into its own thread:
1. Create a Frontend class that extends AbstractHandler and implements Runnable
2. Move the frontend handling logic from Main into the run() method of Frontend
3. Add a handleCount field to Frontend of type AtomicInteger
4. In the run() method, periodically log the value of handleCount every 5 seconds
5. In the handle() method, increment handleCount using getAndIncrement() after generating the page
6. From Main, instantiate a Frontend object and call start() on its thread to run asynchronously
This will separate the frontend into its own thread of execution. The handleCount field
OBJECTS IN Object Oriented Programming .pptSaadAsim11
An object is an instance of a class that has an identity, state, and behavior. The identity is defined by the object's name, state represents the data values of its attributes, and behavior is represented by the functions defined in its class. Objects can be created by declaring a variable of a class type, which allocates memory for the object. Objects can be passed as arguments to functions by value, making a copy, or by reference, where changes made inside the function affect the actual object. A method can return an object as the return value.
1. The document discusses the evolution of the C# programming language from versions 1.0 through 4.0, highlighting new features introduced in each version such as generics, LINQ, dynamic programming, and covariance/contravariance.
2. It provides code examples to illustrate key concepts like generics, LINQ queries, dynamic binding, and how covariance/contravariance enables safer usage of generics.
3. The last section summarizes some of the main features introduced in each C# version from managed code to generics to dynamic programming.
The document discusses new features in C# 8 including readonly members, default interface methods, pattern matching with switch expressions and property patterns, using declarations, static local functions, asynchronous streams with IAsyncEnumerable, and null-coalescing assignment. Some key features covered are readonly members to prevent modification of struct fields and methods, default interface methods to provide implementation in interfaces, switch expressions as a cleaner alternative to switch statements, and property patterns for matching on property values in a switch expression.
This document provides an agenda and overview for a 4 hour hands-on workshop on Android development. The agenda covers setting up the development environment, creating a basic "Hello World" app, and building a simple to-do list app to demonstrate core Android concepts like activities, intents, extras, and preferences. The document explains the overall Android architecture and development process using Eclipse, virtual devices, building UI with layouts, and logging with Logcat.
The document discusses SOLID principles of object-oriented design. It provides examples of code that demonstrate poor adherence to SOLID and ways the code can be refactored to better follow SOLID. Specifically, it shows how to apply the single responsibility principle, open/closed principle, Liskov substitution principle, interface segregation principle and dependency inversion principle to structure code for flexibility, reusability and maintainability.
This document discusses class design using inheritance and garbage collection in Java. It describes a Point class with x and y coordinates and a Rectangle class that inherits from Point and adds width and height properties. Code examples show defining the classes, creating Point and Rectangle objects, and drawing them in an applet. The Rectangle class inherits coordinate properties from Point and adds its own methods while Point's static count property tracks the number of objects.
This document discusses using an Event Consumer design pattern to provide a unified approach to callbacks in Android. It describes how the Event Consumer pattern can be used for callbacks from worker threads, between domain objects and interfaces using the Observer pattern, and between activities using intents. The key aspects are using an EventConsumer interface and event IDs to decouple classes, avoiding direct references between callback classes. This provides a cleaner approach than traditional callback interfaces or methods. The document provides examples to illustrate how the pattern can be applied in different callback situations in Android.
The document discusses implementing CQRS and event sourcing patterns using RavenDB for persistence. It begins with an example employee management prototype and identifies issues with the initial approach. It then explores improving the model by defining commands, events, and having entities generate events in response to commands. Events are stored in RavenDB to rebuild entity state and allow queries to be answered from the event stream. The document provides examples of handling commands, generating and applying events, and saving events to documents in RavenDB.
We're taking a closer look into a new utility class from Android Support Library. It enables you to calculate the difference between two lists and output a list of update operations swiftly and with style. Presented by Željko Plesac from Infinum.
This document discusses using Inter-Process Communication (IPC) mechanisms like Intent, Messenger, and Android Interface Definition Language (AIDL) to allow processes to communicate with each other in an Android app. It provides code examples of implementing IPC using each mechanism to allow a Service to communicate long-running tasks back to an Activity. AIDL is presented as the preferred solution as it allows for synchronous calls, treats the communication in an object-oriented way, and is transparent to the business logic.
This document discusses using Inter-Process Communication (IPC) mechanisms like Intent, Messenger, and Android Interface Definition Language (AIDL) to allow processes to communicate with each other in an Android app. It provides code examples of implementing IPC using each mechanism to allow a Service running in a separate process to communicate tasks and results back to an Activity. AIDL is presented as the most robust solution, allowing synchronous and asynchronous remote calls between processes through generated Java interface stubs.
Not so long ago Microsoft announced a new language trageting on front-end developers. Everybody's reaction was like: Why?!! Is it just Microsoft darting back to Google?!
So, why a new language? JavaScript has its bad parts. Mostly you can avoid them or workaraund. You can emulate class-based OOP style, modules, scoping and even run-time typing. But that is doomed to be clumsy. That's not in the language design. Google has pointed out these flaws, provided a new language and failed. Will the story of TypeScript be any different?
Do not repeat yourself, we teach every fledgling software developer. It makes sense as with growing code redundancy the maintenance cost increase. Simple tools such as functions or loops are a great ways to reduce code redundancy but in our quest to avoid code redundancy we sometimes indulge into complexity. Complex code is also costly to maintain. I will demonstrate, using real-world examples, how one can adopt metaprogramming to minimize code redundancy as well keeping the code simple enough for my mom to understand it.
Since these presentations were spare time hobby - I've decided to share them :)
Hopefully someone will find them useful.
This part continues 1. part with more design patterns like Command, State, NullObject.
This document discusses several common design patterns used in software development including Singleton, Registry, Factory, Adapter, Decorator, and Observer. It provides examples of how each pattern can be implemented in PHP code. The Singleton pattern ensures only one instance of a class can exist. The Registry pattern acts as a singleton for singletons. The Factory pattern handles object creation. The Adapter pattern makes one interface compatible with another. The Decorator pattern allows behavior to be added to individual objects. The Observer pattern notifies observers when a subject changes state.
The document summarizes new features that have been added to C# programming language over different versions of Visual Studio. It discusses features such as generics, lambda expressions, LINQ, tuples, pattern matching, exception filters, auto-property initializers, expression-bodied members and more. It also provides code examples to illustrate some of these features like tuples, deconstruction, pattern matching with case statements, async Main method and others.
Similaire à Lowering in C#: What really happens with your code?, from NDC Oslo 2019 (20)
Orca: Nocode Graphical Editor for Container OrchestrationPedro J. Molina
Tool demo on CEDI/SISTEDES/JISBD2024 at A Coruña, Spain. 2024.06.18
"Orca: Nocode Graphical Editor for Container Orchestration"
by Pedro J. Molina PhD. from Metadev
Mobile App Development Company In Noida | Drona InfotechDrona Infotech
React.js, a JavaScript library developed by Facebook, has gained immense popularity for building user interfaces, especially for single-page applications. Over the years, React has evolved and expanded its capabilities, becoming a preferred choice for mobile app development. This article will explore why React.js is an excellent choice for the Best Mobile App development company in Noida.
Visit Us For Information: https://www.linkedin.com/pulse/what-makes-reactjs-stand-out-mobile-app-development-rajesh-rai-pihvf/
Odoo releases a new update every year. The latest version, Odoo 17, came out in October 2023. It brought many improvements to the user interface and user experience, along with new features in modules like accounting, marketing, manufacturing, websites, and more.
The Odoo 17 update has been a hot topic among startups, mid-sized businesses, large enterprises, and Odoo developers aiming to grow their businesses. Since it is now already the first quarter of 2024, you must have a clear idea of what Odoo 17 entails and what it can offer your business if you are still not aware of it.
This blog covers the features and functionalities. Explore the entire blog and get in touch with expert Odoo ERP consultants to leverage Odoo 17 and its features for your business too.
An Overview of Odoo ERP
Odoo ERP was first released as OpenERP software in February 2005. It is a suite of business applications used for ERP, CRM, eCommerce, websites, and project management. Ten years ago, the Odoo Enterprise edition was launched to help fund the Odoo Community version.
When you compare Odoo Community and Enterprise, the Enterprise edition offers exclusive features like mobile app access, Odoo Studio customisation, Odoo hosting, and unlimited functional support.
Today, Odoo is a well-known name used by companies of all sizes across various industries, including manufacturing, retail, accounting, marketing, healthcare, IT consulting, and R&D.
The latest version, Odoo 17, has been available since October 2023. Key highlights of this update include:
Enhanced user experience with improvements to the command bar, faster backend page loading, and multiple dashboard views.
Instant report generation, credit limit alerts for sales and invoices, separate OCR settings for invoice creation, and an auto-complete feature for forms in the accounting module.
Improved image handling and global attribute changes for mailing lists in email marketing.
A default auto-signature option and a refuse-to-sign option in HR modules.
Options to divide and merge manufacturing orders, track the status of manufacturing orders, and more in the MRP module.
Dark mode in Odoo 17.
Now that the Odoo 17 announcement is official, let’s look at what’s new in Odoo 17!
What is Odoo ERP 17?
Odoo 17 is the latest version of one of the world’s leading open-source enterprise ERPs. This version has come up with significant improvements explained here in this blog. Also, this new version aims to introduce features that enhance time-saving, efficiency, and productivity for users across various organisations.
Odoo 17, released at the Odoo Experience 2023, brought notable improvements to the user interface and added new functionalities with enhancements in performance, accessibility, data analysis, and management, further expanding its reach in the market.
Using Query Store in Azure PostgreSQL to Understand Query PerformanceGrant Fritchey
Microsoft has added an excellent new extension in PostgreSQL on their Azure Platform. This session, presented at Posette 2024, covers what Query Store is and the types of information you can get out of it.
Malibou Pitch Deck For Its €3M Seed Roundsjcobrien
French start-up Malibou raised a €3 million Seed Round to develop its payroll and human resources
management platform for VSEs and SMEs. The financing round was led by investors Breega, Y Combinator, and FCVC.
Everything You Need to Know About X-Sign: The eSign Functionality of XfilesPr...XfilesPro
Wondering how X-Sign gained popularity in a quick time span? This eSign functionality of XfilesPro DocuPrime has many advancements to offer for Salesforce users. Explore them now!
A Comprehensive Guide on Implementing Real-World Mobile Testing Strategies fo...kalichargn70th171
In today's fiercely competitive mobile app market, the role of the QA team is pivotal for continuous improvement and sustained success. Effective testing strategies are essential to navigate the challenges confidently and precisely. Ensuring the perfection of mobile apps before they reach end-users requires thoughtful decisions in the testing plan.
DevOps Consulting Company | Hire DevOps Servicesseospiralmantra
Spiral Mantra excels in providing comprehensive DevOps services, including Azure and AWS DevOps solutions. As a top DevOps consulting company, we offer controlled services, cloud DevOps, and expert consulting nationwide, including Houston and New York. Our skilled DevOps engineers ensure seamless integration and optimized operations for your business. Choose Spiral Mantra for superior DevOps services.
https://www.spiralmantra.com/devops/
Boost Your Savings with These Money Management AppsJhone kinadey
A money management app can transform your financial life by tracking expenses, creating budgets, and setting financial goals. These apps offer features like real-time expense tracking, bill reminders, and personalized insights to help you save and manage money effectively. With a user-friendly interface, they simplify financial planning, making it easier to stay on top of your finances and achieve long-term financial stability.
8 Best Automated Android App Testing Tool and Framework in 2024.pdfkalichargn70th171
Regarding mobile operating systems, two major players dominate our thoughts: Android and iPhone. With Android leading the market, software development companies are focused on delivering apps compatible with this OS. Ensuring an app's functionality across various Android devices, OS versions, and hardware specifications is critical, making Android app testing essential.
Transforming Product Development using OnePlan To Boost Efficiency and Innova...OnePlan Solutions
Ready to overcome challenges and drive innovation in your organization? Join us in our upcoming webinar where we discuss how to combat resource limitations, scope creep, and the difficulties of aligning your projects with strategic goals. Discover how OnePlan can revolutionize your product development processes, helping your team to innovate faster, manage resources more effectively, and deliver exceptional results.
WWDC 2024 Keynote Review: For CocoaCoders AustinPatrick Weigel
Overview of WWDC 2024 Keynote Address.
Covers: Apple Intelligence, iOS18, macOS Sequoia, iPadOS, watchOS, visionOS, and Apple TV+.
Understandable dialogue on Apple TV+
On-device app controlling AI.
Access to ChatGPT with a guest appearance by Chief Data Thief Sam Altman!
App Locking! iPhone Mirroring! And a Calculator!!
WMF 2024 - Unlocking the Future of Data Powering Next-Gen AI with Vector Data...Luigi Fugaro
Vector databases are transforming how we handle data, allowing us to search through text, images, and audio by converting them into vectors. Today, we'll dive into the basics of this exciting technology and discuss its potential to revolutionize our next-generation AI applications. We'll examine typical uses for these databases and the essential tools
developers need. Plus, we'll zoom in on the advanced capabilities of vector search and semantic caching in Java, showcasing these through a live demo with Redis libraries. Get ready to see how these powerful tools can change the game!
Baha Majid WCA4Z IBM Z Customer Council Boston June 2024.pdfBaha Majid
IBM watsonx Code Assistant for Z, our latest Generative AI-assisted mainframe application modernization solution. Mainframe (IBM Z) application modernization is a topic that every mainframe client is addressing to various degrees today, driven largely from digital transformation. With generative AI comes the opportunity to reimagine the mainframe application modernization experience. Infusing generative AI will enable speed and trust, help de-risk, and lower total costs associated with heavy-lifting application modernization initiatives. This document provides an overview of the IBM watsonx Code Assistant for Z which uses the power of generative AI to make it easier for developers to selectively modernize COBOL business services while maintaining mainframe qualities of service.
2. @davidwengier
foreach (int item in listOfInts)
{
// do something with item
}
for (int i = 0; i < listOfInts.Count; i++)
{
int item = listOfInts[i];
// do something with item
}
int i = 0;
while (i < listOfInts.Count)
{
int item = listOfInts[i];
// do something with item
i++;
}
int i = 0;
again:
int item = listOfInts[i];
// do something with item
i++;
if (i < listOfInts.Count)
{
goto again;
}
IL_0024: ldloc.0
IL_0025: ldloc.1
IL_0026: callvirt instance !0 class
[mscorlib]List`1<int32>::get_Item(int32)
IL_002b: pop
IL_002c: ldloc.1
IL_002d: ldc.i4.1
IL_002e: add
IL_002f: stloc.1
IL_0030: ldloc.1
IL_0031: ldloc.0
IL_0032: callvirt instance int32 class
[mscorlib]List`1<int32>::get_Count()
IL_0037: blt.s IL_0024
What is lowering?
IL
foreach
for
while
gotogoto
while
for
foreach
3. @davidwengier
What is lowering?
“A common technique … is to have the compiler
“lower” from high-level language features to low-level
language features in the same language.”
Eric Lippert
https://ericlippert.com/2014/04/28/lowering-in-language-design-part-one/
12. @davidwengier
foreach
{
var e = values.GetEnumerator();
try
{
int m;
while (e.MoveNext())
{
m = (int)(int)e.Current;
Console.WriteLine(m);
}
}
finally
{
if (e != null && e is IDisposable)
{
((IDisposable)e).Dispose();
}
}
}
object[] v = new [] { 1, 2 };
Write(v);
void Write(object[] arr)
{
foreach (int s in arr)
{
Console.WriteLine(s);
}
}
Person[] v = new [] { Empl(),..};
Write(v);
void Write(Person[] arr)
{
foreach (Customer c in arr)
{
Handle(c);
}
}
13. @davidwengier
foreach (C# 5+)
{
var e = values.GetEnumerator();
try
{
while (e.MoveNext())
{
int m;
m = (int)(int)e.Current;
Console.WriteLine(m);
}
}
finally
{
if (e != null && e is IDisposable)
{
((IDisposable)e).Dispose();
}
}
}
16. @davidwengier
Lambdas
public class C
{
public void M()
{
ActHelper c = new ActHelper();
Action<string> act = c.act;
act(“hello”);
}
private class ActHelper
{
internal void act(string x)
{
Console.WriteLine(x);
}
}
}
17. @davidwengier
Lambdas
public class C
{
public void M()
{
if (ActHelper.Instance._act == null)
{
ActHelper.Instance._act = new Action<string>(ActHelper.Instance.act);
}
Action<string> act = ActHelper.Instance._act;
act(“hello”);
}
private sealed class ActHelper
{
public static readonly ActHelper Instance = new ActHelper();
public static Action<string> _act;
internal void act(string x)
{
Console.WriteLine(x);
}
}
}
18. @davidwengier
public class C
{
public void M()
{
Action<string> act = x => Console.WriteLine(x);
act(“Hello”);
}
}
public class C
{
public void M()
{
ActHelper c = new ActHelper();
Action<string> act = c.act;
act(“Hello”);
}
private sealed class ActHelper
{
internal void act(string x)
{
Console.WriteLine(x);
}
}
}
19. @davidwengier
public class C
{
public void M()
{
string y = “ World”;
Action<string> act = x => Console.WriteLine(x + y);
act(“Hello”);
}
}
public class C
{
public void M()
{
ActHelper c = new ActHelper();
Action<string> act = c.act;
act(“Hello”);
}
private sealed class ActHelper
{
internal void act(string x)
{
Console.WriteLine(x + y);
}
}
}
public class C
{
public void M()
{
ActHelper c = new ActHelper();
Action<string> act = c.act;
act(“Hello”);
}
private sealed class ActHelper
{
public string y;
internal void act(string x)
{
Console.WriteLine(x + y);
}
}
}
public class C
{
public void M()
{
ActHelper c = new ActHelper();
c.y = “ World”;
Action<string> act = c.act;
act(“Hello”);
}
private sealed class ActHelper
{
public string y;
internal void act(string x)
{
Console.WriteLine(x + y);
}
}
}
20. @davidwengier
public class C
{
public void M()
{
string y = “ World”;
Action<string> act = x => Console.WriteLine(x + y);
y = “ Fish”;
act(“Hello”);
}
}
public class C
{
public void M()
{
ActHelper c = new ActHelper();
c.y = “ World”;
Action<string> act = c.act;
act(“Hello”);
}
private sealed class ActHelper
{
public string y;
internal void act(string x)
{
Console.WriteLine(x + y);
}
}
}
21. @davidwengier
public class C
{
public void M()
{
string y = “ World”;
Action<string> act = x => Console.WriteLine(x + y);
y = “ Fish”;
act(“Hello”);
}
}
public class C
{
public void M()
{
ActHelper c = new ActHelper();
c.y = “ World”;
Action<string> act = c.act;
c.y = “ Fish”;
act(“Hello”);
}
private sealed class ActHelper
{
public string y;
internal void act(string x)
{
Console.WriteLine(x + y);
}
}
}
23. @davidwengier
Foreach and lambdas
List<Action> things = new List<Action>();
{
var e = values.GetEnumerator();
try
{
ActHelper c = new ActHelper();
while (e.MoveNext())
{
c.m = (int)(int)e.Current;
things.Add(new Action(c.act));
}
}
finally
{
if (e != null && e is IDisposable) ((IDisposable)e).Dispose();
}
}
24. @davidwengier
Foreach and lambdas (C# 5+)
List<Action> things = new List<Action>();
{
var e = values.GetEnumerator();
try
{
while (e.MoveNext())
{
ActHelper c = new ActHelper();
c.m = (int)(int)e.Current;
things.Add(new Action(c.act));
}
}
finally
{
if (e != null && e is IDisposable) ((IDisposable)e).Dispose();
}
}
25. @davidwengier
public class C
{
private int z;
public void M()
{
string y = “ World”;
Action<string> act = x => Console.Write(x + y + z);
act(“Hello”);
}
}
public class C
{
private int z;
public void M()
{
ActHelper c = new ActHelper();
c.y = “ World”;
c._this = this;
c.act(“Hello”);
}
private sealed class ActHelper
{
public C _this;
public string y;
internal void act(string x)
{
Console.Write(x + y + _this.z);
}
}
}
31. @davidwengier
Yield states
-2 : GetEnumerator() hasn’t been called
-1 : Running – Getting the next value
0 : Before – MoveNext() hasn’t been called
1- 4 : Suspended – Waiting for a MoveNext() call
5 : After – Finished.
36. @davidwengier
Yield states
-3 : Running – Getting the next value
-2 : GetEnumerator() hasn’t been called
-1 : Running – Getting the range enumerator
0 : Before – MoveNext() hasn’t been called
1 : Suspended (and After) – Waiting for a MoveNext() call
37. @davidwengier
Captain planet
private int _min;
public void M()
{
int max = 5;
foreach (int x in GetInts(max))
{
Console.WriteLine(x);
}
}
public IEnumerable<int> GetInts(int max)
{
yield return 1;
foreach (int x in Enumerable.Range(this._min, max).OrderBy(i => i * this._min + max))
{
yield return x;
}
}
???
Invented a language, having a language design meeting. Someone suggests “foreach”. Everyone agrees, except the guy in the corner. Lowering. He’s lazy. “why not just use a for loop”
Because I love it!
One abstraction layer deeper
Debugging
Performance
Lets look at one of those previous examples in detail.
Lets look at one of those previous examples in detail.
Simplified generic version. There are specific overloads for arrays, stirngs etc.
No type on GetEnumerator. Duck typing. Not really var, the compiler works it out, I just can’t express it. Also checks for implicit implementations and casts to IEnumerable. If necessary.
Two casts. One for item type, one for the type of the loop variable (because designed before generics, eg ArrayList). Means you can loop through objects, and ask for strings. EG ANIMATIONS!! Those casts could fail.
Disposable is optional. Compiler will work out whether to include it (and will leave off the try..finally entirely if it can
Note the brackets to introduce a new scope
This is the C# 4 and below version.
Subtle difference. Variable declaration inside while loop. This is a breaking change. Why? Answer is closures, which brings us to our next bit of lowering.
To talk about closures, I think its easiest to talk about lambdas.
This is what it logically does, however this has a problem. Without knowing what Console.WriteLine does, and depending on what is passed in, we can’t guarantee this doesn’t hold a reference to class C. So instead this is what the compiler does:
By using a new class, even if an instance is held in memory the compiler knows its as small as it can be. Obviously these method and class names would be different. In fact, compiler deliberately uses names that are invalid C#
This is _really_ what the compiler does though. Apologies for the size.. Various optimizations.
So far so good? Cool.
The other thing we can do wth lambdas and delegates is create closures.
Lets go back to our original lamba, but make a small change. This action now creates a closure over y. Now the compiler has to put y in the new class, and store a reference to it. This looks like this.
Lets go back to our original lamba, but make a small change. This action now creates a closure over y. Now the compiler has to put y in the new class, and store a reference to it. This looks like this.
So, can you see the problem? It doesn’t matter when you create the delegate, we’ve capture the variable y, not the value of the variable y. So the code uses the value of the variable y as at the time it is executed.
So, can you see the problem? It doesn’t matter when you create the delegate, we’ve capture the variable y, not the value of the variable y. So the code uses the value of the variable y as at the time it is executed.
So lets revisit our foreach loop, but now add a lambda in the middle. We’ll just collect a list of things to do later.. Call it poor mans async
Now this gets expanded as we know. I’ve highlighted the new bits.
In C# 5 however, we now move the declaration of m inside the loop, therefore we don’t have a problem.. Essentially when C# 4 came out everyone was so lambda happy that it exposed this quirk.
Why did they do it the other way first? Matches the “for” semantics, of having one loop variable that is redefined. Just that with “for” its much more obvious, because the user is writing that redefinition.
One last word on closures, is what the difference is when we close over a class level field, property, method etc. The field is not hoisted, instead the helper class has a reference to the original object. This can potentially lead to memory leaks. Solved by introducing local variables to capture the value, though does change the semantics (value capture not variable capture)
Kinda still on foreaches, lets look at the yield statement. Things get pretty tricky with this one.. So any questions before we continue?
The foreach part we know, and GetInts is still a method that returns an enumerable. The content of GetInts has been moved to a new class though, like we saw with lambdas. Lets look at that class
So, it implements a few interfaces. And mose of these things are obvious.
It captures the thread id, which we’ll see later is used for thread safety. It implements Idisposable as a just in case, and in this case doesn’t need to dispose anything. Will see more later.
Current we’ve seen before from Ienumerable, and there is a local variable to track it.
And it stores state. As you might know, or have guessed, the yield enumerator uses a state machine.
The intial state, if you remember, is -2
Here is the GetEnumerator method. This is where we do some thread checking. So if GetEnumerator() is called from the same thread, and we have our initial state, then this is the thing we use. This is what allows our class to be an enumerable, that can be returned from GetInts(), and an enumerator, that can do the enumeration. This sets the state to 0.
If something else calls GetEnumerator(), or we’re in a different state, then return a new instance with a 0 initial state.
Pretty basic state machine. Essentially its an unrolled loop, which makes sense because if you think about our yield statement, that was too. 4 states: Before (-2, 0), Running (-1), Suspended and After (positive integers)
Questions?
More realistic uses get a bit harder, so lets look at one.
This is a bit more typical, where in your method you’d be looping through something else, and yield returning. If the yield return unrolls the loop, well what happens when you put a loop in your loop unrolling?
Lets look at the differences.
A new Enumerator field, called wrap. In Dispose we call Finally, and that disposes of the wrapped enumerator.
The weird empty try..finally block, I cannot explain!. Could be a decompilation problem.
Just to save space on the next slide, MoveNext has nothing new that’s interesting.. Just a dispose call in a catch
Hopefully still big enough.. This looks very different! But its still a state machine. Initial state is 0, so first we set state to -3 (another type of “Running” - about get next), and get a reference to the range enumerator. Then we call MoveNext, set state to 1. Each call to this MoveNext calls the wrapped MoveNext, until we run out. At the end we call Finally() again. -1 is running the GetEnumerator, -3 is running the MoveNext
This instance doesn’t really have an “After” because it doesn’t know when to stop on its own, it simply passes calls on to the wrapped enumerator, and hence relies on that enumerators After state.
And of course you can combine these things, by having multiple yield returns, the iterator can close over variables, and fields, and can include a lambda that does the same!
This is why lowering is good. No need to implement all of this lot in IL. We know this bit will become a class, closing over some things.. And this…
At the end it will just be classes with straight forward code, containing pretty much just gotos