Code Generation with tools such as Groovy, Lombok, AutoValue and Immutables will reduce boilerplate from your code and makes it more readable. An overview of creating value objects, immutability and how they do annotation processing.
This document discusses object-oriented programming in JavaScript. It covers built-in objects like Object, Function, and Array. It also discusses creating custom objects using constructor functions and prototypes. Constructor functions allow initializing object state, while prototypes allow defining shared object behavior. JavaScript uses prototypal inheritance, where an object inherits directly from another object instance.
This document summarizes a presentation about Kotlin features for Android development. It discusses Kotlin's concise syntax, null safety, lambdas, extension functions, and higher-order functions. It also covers Kotlin collections, coroutines, Anko for layouts and SQLite, and migrating existing Android projects to Kotlin. The presentation provides code examples for many of these features and recommends additional Kotlin learning resources.
This document introduces developing device-adaptive apps using KDE Plasma technologies. It discusses adapting the UI for different devices rather than simplifying for one, using reusable components, Qt Quick/QML for declarative UI development, and extending QML with C++. It also covers Plasma Quick for KDE/Plasma libraries, tools like Plasmate and Mer SDK, and getting help from the KDE community.
This document provides an overview of the Kotlin programming language. Kotlin is a statically typed language that runs on the JVM and has design goals of being concise, safe, interoperable, and tool-friendly. It aims to mitigate weaknesses from Java like boilerplate code and unsafe nulls. Key features discussed include null safety, data classes, higher-order functions, lambdas, and functional-style programming with collections. The document also provides code samples and compares Kotlin's source code organization and packages to Java.
Java objects go through several phases in their lifecycle:
1. Creation occurs when memory is allocated and the constructor is called.
2. In use refers to objects that are still referenced by the program.
3. Unreachable means there are no longer any references to the object, making it eligible for garbage collection.
4. Collection and finalization are garbage collection phases where unreachable objects have their memory reclaimed.
This document discusses understanding Pharo's global state in order to move programs across environments. It presents a classification of global state usage and detects a need to make implicit elements like caches and singletons more explicit through reification. It also detects a need to move some responsibilities for managing global state to the language itself, so the system can introspect, modify and control aspects like flushing caches during low memory.
This document discusses object-oriented programming in JavaScript. It covers built-in objects like Object, Function, and Array. It also discusses creating custom objects using constructor functions and prototypes. Constructor functions allow initializing object state, while prototypes allow defining shared object behavior. JavaScript uses prototypal inheritance, where an object inherits directly from another object instance.
This document summarizes a presentation about Kotlin features for Android development. It discusses Kotlin's concise syntax, null safety, lambdas, extension functions, and higher-order functions. It also covers Kotlin collections, coroutines, Anko for layouts and SQLite, and migrating existing Android projects to Kotlin. The presentation provides code examples for many of these features and recommends additional Kotlin learning resources.
This document introduces developing device-adaptive apps using KDE Plasma technologies. It discusses adapting the UI for different devices rather than simplifying for one, using reusable components, Qt Quick/QML for declarative UI development, and extending QML with C++. It also covers Plasma Quick for KDE/Plasma libraries, tools like Plasmate and Mer SDK, and getting help from the KDE community.
This document provides an overview of the Kotlin programming language. Kotlin is a statically typed language that runs on the JVM and has design goals of being concise, safe, interoperable, and tool-friendly. It aims to mitigate weaknesses from Java like boilerplate code and unsafe nulls. Key features discussed include null safety, data classes, higher-order functions, lambdas, and functional-style programming with collections. The document also provides code samples and compares Kotlin's source code organization and packages to Java.
Java objects go through several phases in their lifecycle:
1. Creation occurs when memory is allocated and the constructor is called.
2. In use refers to objects that are still referenced by the program.
3. Unreachable means there are no longer any references to the object, making it eligible for garbage collection.
4. Collection and finalization are garbage collection phases where unreachable objects have their memory reclaimed.
This document discusses understanding Pharo's global state in order to move programs across environments. It presents a classification of global state usage and detects a need to make implicit elements like caches and singletons more explicit through reification. It also detects a need to move some responsibilities for managing global state to the language itself, so the system can introspect, modify and control aspects like flushing caches during low memory.
- Oslo.versionedobjects is an object model used in Nova to version and serialize objects for remote procedure calls (RPCs). Each change is versioned to allow backwards-compatible evolution.
- Objects define fields and methods, with fields serialized independently of code. Versioning allows controlled schema changes without database changes.
- Objects can be remotely called via an indirection service, with copies sent and returned. This decouples services from databases, enabling independent upgrades.
If you still haven't heard of it, there is a new star in JVM sky - Kotlin. This short presentation will serve as intro for those who wan't to hear what's all the fuss about and dive deeper into this new alternative to Java
Inspirations for this presentation were drawn from a couple of sprints in one of our internal projects in which we had the freedom of choosing our own technical solutions.
We go through premature optimisation, silver-bullet antipattern, duplication and null-pointer hell.
In the end other antipatterns are swiftly mentioned.
This presentation is devoted to the user interface component decomposition technique. As examples of React-thinking, speaker reviewed popular libraries, such as "react-router", "formik", etc.
This presentation was held by Igor Nesterenko (Lead Software Engineer, Consultant, GlobalLogic, Kharkiv) at GlobalLogic Kharkiv JS TechTalk #3 on December 11, 2018.
Video: https://youtu.be/IcMY0nvIqgY
With a group of like-minded and like-located smalltalkers, we have created the Github group "Buenos Aires Smalltalk" (BA-ST for short).
In it we have been sharing a set of interconnected projects, that would allow many of the architectural challenges of current applications to be available from the start.
You already know about Willow, but there are others. This talk will present an overview of some of these projects and what you can do with them, from configuring a new Github project, to working with graphs, state machines, systems and model creation, to name a few.
Kotlin is a statically typed programming language that targets the JVM, Android, JavaScript and Native platforms. It was developed by JetBrains and released in version 1.0 in 2016. Kotlin aims to be concise, safe, pragmatic and focused on interoperability with Java. It can be used for both server-side and Android development and works with existing Java libraries and frameworks.
This document discusses object-oriented programming concepts like messaging, polymorphism, and encapsulation and compares different implementations across languages like Ruby, Java, JavaScript, and Perl. It notes that while OOP can be implemented simply using data structures or more complexly with first-class classes, the goal is the same - to support messaging between objects and dynamic dispatch. It concludes that many approaches can achieve "objects" and that programmers should understand multiple language implementations since each one comes with constraints.
Go (often referred to as “Golang”) is a fairly new programming language, version 1.0 released in 2012. Its three creators include Ken Thompson, who is the legendary father of UNIX and the inventor of the C language. The motives behind Go are very similar to those behind Java’s origins: much easier to use than C/C++, automatic garbage collection, no pointer arithmetic, built-in concurrency support, rich standard library, strong networking support.
Davide Cerbo - Kotlin loves React - Codemotion Milan 2018Codemotion
Kotlin è un linguaggio basato sulla JVM che si sta sviluppando molto rapidamente. Ma il suo scopo non è solo conquistare la JVM, ma ogni piattaforma. Durante il talk vedremo come sviluppare una applicazione web utilizzando React e Kotlin e analizzeremo quali sono i vantaggi di usare un linguaggio staticamente tipizzato nello sviluppo frontend.
Groovy is a dynamic programming language for the Java Virtual Machine that aims to be more concise and productive for the Java developer. It builds upon Java by adding features like dynamic typing, closures, operator overloading, and GStrings. Groovy can be used for scripting, unit testing, configuration management, and full applications through frameworks like Grails and Griffon.
Swift is a protocol-oriented programming language that was announced in 2014 and made open-source in 2015. Some key features of Swift include protocol-oriented programming, literals that can be initialized in multiple ways, generics for type-safe operations on different types, operators for common tasks, and value types for safety. Swift aims to provide modern features while integrating well with Apple platforms like iOS and bridging to Objective-C code.
Dart is a new language for the web, enabling you to write JavaScript on a secure and manageable way. No need to worry about "JavaScript: The bad parts".
This presentation concentrates on the developer experience converting from the Java based GWT to Dart.
Kotlin is a programming language that runs on the Java Virtual Machine and JavaScript. It was created by JetBrains as an alternative to Java that allows code to be written in fewer lines using less verbose syntax. Kotlin is fully interoperable with Java code and is becoming a preferred language for Android development due to its support by Android Studio. The document discusses Kotlin's history, capabilities, and provides examples of how code can be written more concisely in Kotlin compared to Java. It recommends resources for learning Kotlin and says that while there is a learning curve, it may be beneficial for new projects, especially Android development.
Slide 2:
What are the Constructor & destructor ?
Slide 3:
Characteristics of Constructor
Slide 4:
Special CHaracteristics of Destructor
Slide 5:
Similarities
Slide 6:
Dissimilarities
Slides 7:
Default Constructor with example
Slide 8:
Parameterized Constructor
Slide 9:
Copy Constructor with example
Slide 10:
Destructor
Slide 11:
Bibliography
This document provides an overview of C# basics and .NET fundamentals. It discusses key .NET concepts like assemblies, namespaces, types, variables, and object-oriented principles. It also covers memory management handled by the common language runtime (CLR) through garbage collection. The CLR manages memory on the managed heap and uses generations and finalization to clean up unreachable objects. Classes dealing with unmanaged resources should implement IDisposable and the dispose pattern to properly free resources.
A Type-level Ruby Interpreter for Testing and Understandingmametter
Type Profiler is a type analyzer for Ruby 3 that analyzes non-annotated Ruby code. It runs Ruby code at the type level to find potential errors and prototype type signatures. It forks execution for branches and reuses results when possible. While not perfect, it provides basic type checking capabilities for Ruby without requiring type annotations. The author acknowledges limitations and many areas for future work to improve Type Profiler.
Stefan Richter - Writing simple, readable and robust code: Examples in Java, ...AboutYouGmbH
Stefan Richter gave a presentation on writing simple, readable, and robust code using examples in Java, Clojure, and Go. He discussed his programming experience and showed how Martin Fowler used Java to parse a fixed-length file format into objects. Richter then demonstrated how the same task could be accomplished more concisely in Common Lisp and Clojure using macros to define domain-specific languages. He argued that macros are a powerful feature of Lisp-like languages.
TypeScript 2 provides several new features that improve type safety when using TypeScript with libraries like React and Redux. These include non-nullable types to prevent null/undefined errors, literal types for exact string/number values, discriminated union types for handling different action types in Redux, and mapped/partial types for better React prop and state typing. Overall, TypeScript 2 enhances type checking and brings tighter integration with popular JavaScript frameworks and patterns.
Kotlin is a statically typed programming language for the JVM, Android and the browser designed for the industry. This presentation is an overview of Kotlin features and advantages over Java including code samples.
Lombok is a Java library that automatically plugs into your build and generates code and boilerplate code for common patterns. It offers features like @ToString to generate toString() methods, @Getter and @Setter to generate getters and setters, @Cleanup for automatic resource cleanup, and more. These annotations allow code to be written more concisely and clearly without a lot of repetitive boilerplate code.
The document discusses code generation on the JVM using various tools and frameworks. It provides an overview of Lombok for generating Java boilerplate code, Groovy AST transformations, CodeNarc for static analysis, and Spock, GContracts, and Groovy++ for framework-oriented code generation. It also discusses generating code at compile time using abstract syntax trees.
- Oslo.versionedobjects is an object model used in Nova to version and serialize objects for remote procedure calls (RPCs). Each change is versioned to allow backwards-compatible evolution.
- Objects define fields and methods, with fields serialized independently of code. Versioning allows controlled schema changes without database changes.
- Objects can be remotely called via an indirection service, with copies sent and returned. This decouples services from databases, enabling independent upgrades.
If you still haven't heard of it, there is a new star in JVM sky - Kotlin. This short presentation will serve as intro for those who wan't to hear what's all the fuss about and dive deeper into this new alternative to Java
Inspirations for this presentation were drawn from a couple of sprints in one of our internal projects in which we had the freedom of choosing our own technical solutions.
We go through premature optimisation, silver-bullet antipattern, duplication and null-pointer hell.
In the end other antipatterns are swiftly mentioned.
This presentation is devoted to the user interface component decomposition technique. As examples of React-thinking, speaker reviewed popular libraries, such as "react-router", "formik", etc.
This presentation was held by Igor Nesterenko (Lead Software Engineer, Consultant, GlobalLogic, Kharkiv) at GlobalLogic Kharkiv JS TechTalk #3 on December 11, 2018.
Video: https://youtu.be/IcMY0nvIqgY
With a group of like-minded and like-located smalltalkers, we have created the Github group "Buenos Aires Smalltalk" (BA-ST for short).
In it we have been sharing a set of interconnected projects, that would allow many of the architectural challenges of current applications to be available from the start.
You already know about Willow, but there are others. This talk will present an overview of some of these projects and what you can do with them, from configuring a new Github project, to working with graphs, state machines, systems and model creation, to name a few.
Kotlin is a statically typed programming language that targets the JVM, Android, JavaScript and Native platforms. It was developed by JetBrains and released in version 1.0 in 2016. Kotlin aims to be concise, safe, pragmatic and focused on interoperability with Java. It can be used for both server-side and Android development and works with existing Java libraries and frameworks.
This document discusses object-oriented programming concepts like messaging, polymorphism, and encapsulation and compares different implementations across languages like Ruby, Java, JavaScript, and Perl. It notes that while OOP can be implemented simply using data structures or more complexly with first-class classes, the goal is the same - to support messaging between objects and dynamic dispatch. It concludes that many approaches can achieve "objects" and that programmers should understand multiple language implementations since each one comes with constraints.
Go (often referred to as “Golang”) is a fairly new programming language, version 1.0 released in 2012. Its three creators include Ken Thompson, who is the legendary father of UNIX and the inventor of the C language. The motives behind Go are very similar to those behind Java’s origins: much easier to use than C/C++, automatic garbage collection, no pointer arithmetic, built-in concurrency support, rich standard library, strong networking support.
Davide Cerbo - Kotlin loves React - Codemotion Milan 2018Codemotion
Kotlin è un linguaggio basato sulla JVM che si sta sviluppando molto rapidamente. Ma il suo scopo non è solo conquistare la JVM, ma ogni piattaforma. Durante il talk vedremo come sviluppare una applicazione web utilizzando React e Kotlin e analizzeremo quali sono i vantaggi di usare un linguaggio staticamente tipizzato nello sviluppo frontend.
Groovy is a dynamic programming language for the Java Virtual Machine that aims to be more concise and productive for the Java developer. It builds upon Java by adding features like dynamic typing, closures, operator overloading, and GStrings. Groovy can be used for scripting, unit testing, configuration management, and full applications through frameworks like Grails and Griffon.
Swift is a protocol-oriented programming language that was announced in 2014 and made open-source in 2015. Some key features of Swift include protocol-oriented programming, literals that can be initialized in multiple ways, generics for type-safe operations on different types, operators for common tasks, and value types for safety. Swift aims to provide modern features while integrating well with Apple platforms like iOS and bridging to Objective-C code.
Dart is a new language for the web, enabling you to write JavaScript on a secure and manageable way. No need to worry about "JavaScript: The bad parts".
This presentation concentrates on the developer experience converting from the Java based GWT to Dart.
Kotlin is a programming language that runs on the Java Virtual Machine and JavaScript. It was created by JetBrains as an alternative to Java that allows code to be written in fewer lines using less verbose syntax. Kotlin is fully interoperable with Java code and is becoming a preferred language for Android development due to its support by Android Studio. The document discusses Kotlin's history, capabilities, and provides examples of how code can be written more concisely in Kotlin compared to Java. It recommends resources for learning Kotlin and says that while there is a learning curve, it may be beneficial for new projects, especially Android development.
Slide 2:
What are the Constructor & destructor ?
Slide 3:
Characteristics of Constructor
Slide 4:
Special CHaracteristics of Destructor
Slide 5:
Similarities
Slide 6:
Dissimilarities
Slides 7:
Default Constructor with example
Slide 8:
Parameterized Constructor
Slide 9:
Copy Constructor with example
Slide 10:
Destructor
Slide 11:
Bibliography
This document provides an overview of C# basics and .NET fundamentals. It discusses key .NET concepts like assemblies, namespaces, types, variables, and object-oriented principles. It also covers memory management handled by the common language runtime (CLR) through garbage collection. The CLR manages memory on the managed heap and uses generations and finalization to clean up unreachable objects. Classes dealing with unmanaged resources should implement IDisposable and the dispose pattern to properly free resources.
A Type-level Ruby Interpreter for Testing and Understandingmametter
Type Profiler is a type analyzer for Ruby 3 that analyzes non-annotated Ruby code. It runs Ruby code at the type level to find potential errors and prototype type signatures. It forks execution for branches and reuses results when possible. While not perfect, it provides basic type checking capabilities for Ruby without requiring type annotations. The author acknowledges limitations and many areas for future work to improve Type Profiler.
Stefan Richter - Writing simple, readable and robust code: Examples in Java, ...AboutYouGmbH
Stefan Richter gave a presentation on writing simple, readable, and robust code using examples in Java, Clojure, and Go. He discussed his programming experience and showed how Martin Fowler used Java to parse a fixed-length file format into objects. Richter then demonstrated how the same task could be accomplished more concisely in Common Lisp and Clojure using macros to define domain-specific languages. He argued that macros are a powerful feature of Lisp-like languages.
TypeScript 2 provides several new features that improve type safety when using TypeScript with libraries like React and Redux. These include non-nullable types to prevent null/undefined errors, literal types for exact string/number values, discriminated union types for handling different action types in Redux, and mapped/partial types for better React prop and state typing. Overall, TypeScript 2 enhances type checking and brings tighter integration with popular JavaScript frameworks and patterns.
Kotlin is a statically typed programming language for the JVM, Android and the browser designed for the industry. This presentation is an overview of Kotlin features and advantages over Java including code samples.
Lombok is a Java library that automatically plugs into your build and generates code and boilerplate code for common patterns. It offers features like @ToString to generate toString() methods, @Getter and @Setter to generate getters and setters, @Cleanup for automatic resource cleanup, and more. These annotations allow code to be written more concisely and clearly without a lot of repetitive boilerplate code.
The document discusses code generation on the JVM using various tools and frameworks. It provides an overview of Lombok for generating Java boilerplate code, Groovy AST transformations, CodeNarc for static analysis, and Spock, GContracts, and Groovy++ for framework-oriented code generation. It also discusses generating code at compile time using abstract syntax trees.
Writing code that writes code - Nguyen LuongVu Huy
“The Pragmatic Programmer” admonished us all to “write code that writes code”: use code generators to increase productivity and avoid duplication. The language communities have clearly caught on, as more and more frameworks generate code at compile time: Project Lombok, Google Auto, and more.
This session reviews these approaches including examples of how and why we’d want to do this.
We will see newest Java language tools, write our own AST tranform and look at some amazing libraries based on these techniques.
Bio: Nguyen Luong is a senior java technical lead at Ekino Vietnam. He likes to research new technologies and solve security challenges.
“The Pragmatic Programmer” admonished us all to “write code that writes code”: use code generators to increase productivity and avoid duplication. The language communities have clearly caught on, as more and more frameworks generate code at compile time: Project Lombok, Google Auto, and more.
This session reviews these approaches including examples of how and why we’d want to do this.
We will see newest Java language tools, write our own AST tranform and look at some amazing libraries based on these techniques.
Bio: Nguyen Luong is a senior java technical lead at Ekino Vietnam. He likes to research new technologies and solve security challenges.
Infinum android talks_10_getting groovy on androidInfinum
Groovy is a dynamic language similar to Python, Ruby, Pearl and Smalltalk. Since it compiles to Java bytecode it can be used to write Android applications as well. We’ll demonstrate how to setup a Groovy Android application project, show the advantages, disadvantages and provide some code examples.
https://www.youtube.com/watch?v=9yxj9bxQ9H4
The document summarizes the new features in Groovy 1.6, including performance improvements, syntax enhancements, compile-time and runtime metaprogramming additions, the Grape module system for managing script dependencies, improvements to Swing integration, built-in support for the JSR-223 scripting engine, a domain-specific language for JMX, and OSGi readiness. The presentation highlights key new features like annotations, multiple variable assignment, optional returns, and annotation processing through AST transformations.
The document discusses several topics related to Groovy and Grails development:
1) The Groovy Map constructor is not a real constructor but instead calls the default constructor and then sets properties via reflection. It requires an existing default constructor.
2) Using new Date().getTime() to get the current time is not recommended, System.currentTimeMillis() should be used instead for performance reasons.
3) Primitives like boolean and int should be avoided in domain classes in favor of wrapper classes like Boolean and Integer to properly support nullable columns.
This document provides an overview of Groovy AST transformations. It describes what an abstract syntax tree (AST) is and how AST transformations allow extending the Groovy language by manipulating the AST during compilation. It covers local and global AST transformations and examples of Groovy's built-in AST transformations. It also demonstrates how to create a custom AST transformation with an annotation, implementation class, and manually or programmatically building AST nodes.
This document introduces Groovy, a scripting language for Java. It discusses how Groovy compiles to Java bytecode and can be used with existing Java tools and libraries. Examples show how Groovy simplifies common tasks like iteration, exception handling, and building XML/HTML. The document also briefly introduces Grails, a web framework that uses Groovy's conventions to accelerate development.
"Xapi-lang For declarative code generation" By James NelsonGWTcon
Xapi-lang is a Java parser enhanced with an XML-like syntax that can be used for code generation, templating, and creating domain-specific languages. It works by parsing code into an abstract syntax tree and then applying visitors to analyze and transform the AST to produce output. Examples shown include class templating, API generation from templates, and UI component generation. The document also discusses best practices for code generation and outlines plans for rebuilding the GWT toolchain to support GWT 3 and J2CL. It promotes a new company, Vertispan, for GWT support and consulting and introduces another project called We The Internet for building tools to improve political systems using distributed democracy.
The document discusses using Groovy to improve Java testing. Groovy allows writing tests more concisely using features like closures, native list/map syntax, and dynamic proxies. It also enables mocking collaborators without external libraries. Groovy integrates fully with JUnit and TestNG and helps test exceptions, databases using DbUnit, and drive functional UI tests more easily.
Groovy is a dynamic language for the Java Virtual Machine that aims to provide productivity features like closures, builders, and metaprogramming while leveraging Java's capabilities. The document discusses why developers should use Groovy to build Atlassian plugins, noting features like closures, domain specific languages, and builders that improve productivity. It addresses myths that dynamic typing reduces IDE support and that scripting languages are unprofessional. Code examples demonstrate how Groovy code can be more concise and readable than equivalent Java code.
1. The document discusses several tools and techniques for improving Java objects, including making them immutable, improving testing of POJO methods, generating equals, hashCode and toString methods, and improving testing with AssertJ assertions.
2. It recommends using PojoTester to test POJO methods, Pojomatic to generate equals, hashCode and toString, AutoValue for immutable objects, and AssertJ assertions for readable tests.
3. The goals are focusing on objects with less boilerplate, moving toward domain-driven design and hexagonal architecture.
Groovy and Grails in Action - Devoxx 2008 - University - Guillaume LaforgeGuillaume Laforge
The document is a presentation about Groovy and Grails. It discusses the history and goals of Groovy, a dynamic language for the JVM. It covers Groovy syntax and features like closures, builders for XML, Swing and Ant. The presentation also discusses how Groovy enables the creation of internal Domain Specific Languages through its meta-object protocol and dynamic nature.
In this document I show an example of using Use-site targets in Kotlin. This is a relatively misunderstood feature of Kotlin that gets greatly overlooked by developers used to working with annotations in frameworks like the Spring Framework. The idea is that Kotlin doesn't really has a strategy to go about annotations in data classes if we don't specify the target. In Java, the target was very tangible. In Kotlin is all about abstraction. There can be negatives about this or maybe not.
JavaOne 2008 - TS-5793 - Groovy and Grails, changing the landscape of Java EE...Guillaume Laforge
Groovy is a dynamic language for the Java Virtual Machine that integrates with Java. Grails is a web framework built on Groovy that leverages existing Java technologies. The presentation discusses how Groovy's meta-programming capabilities, through its Meta Object Protocol, enable new patterns like dynamic finders that change how we approach common Java patterns like the Data Access Object and Service Locator.
Kotlin - The Swiss army knife of programming languages - Visma Mobile Meet-up...Tudor Dragan
Kotlin is a powerful language, but it also comes with its traps and pitfalls. This presentation is about uncovering the very nice features and strange particularities that the language has to offer.
The document discusses how the Kotlin compiler fakes or lies about certain Kotlin language features by decompiling the bytecode produced by the Kotlin compiler. It provides examples of how free functions, nested functions, primary constructors, extension methods, destructuring, object declarations, companion objects, enumerations, delegated properties, lambdas with receivers, and more are implemented under the hood by the compiler through bytecode tricks and deception. The document is intended to look under the hood of the Kotlin compiler and Java bytecode to understand how certain Kotlin features are implemented that don't have a direct mapping to Java.
Similar to Code Generation with Groovy, Lombok, AutoValue and Immutables - Ted's Tool Time (20)
Spock the enterprise ready specifiation framework - Ted VinkeTed Vinke
Spock is a testing and specification framework for Java and Groovy applications. What makes it stand out from the crowd is its beautiful and highly expressive specification language. Thanks to its JUnit runner, Spock is compatible with most IDEs, build tools, and continuous integration servers. Spock is inspired from JUnit, jMock, RSpec, Groovy, Scala, Vulcans, and other fascinating life forms.
This presentation is an overview of the Spock 1.1 documentation available at http://docs.spockframework.org/
Upcoming Events 2017 for a Java Software Developer - Ted's Tool TimeTed Vinke
An overview of all interesting Java, Agile, Continuous Delivery and DevOps events in 2017, such as tech days and conferences, for a Java Software Developer.
Highlight your emails with important information and actions in Inbox by Gmail. Here I've shown collegues that with a little help from schema.org and Gmail's Email Markup we too can have interactive buttons in our email!
The specification pattern is a particular software design pattern, whereby business rules can be recombined by chaining the business rules together using boolean logic. An example case is explained (where I use the postfix Condition instead of Specification) in Groovy.
JUnit 5 - The Next Generation of JUnit - Ted's Tool TimeTed Vinke
JUnit 5 is the next generation of JUnit. The goal is to create an up-to-date foundation for developer-side testing on the JVM. This includes focusing on Java 8 and above, as well as enabling many different styles of testing.
From the Java Collections Framework to the enhancements Groovy brings to the table when working with Collections. Based on https://tedvinke.wordpress.com/?s=Groovy+Weekend+Collections
The Apache Software Foundation - Ted's Tool Time - Sep 2015Ted Vinke
September's edition of Ted's Tool Time, a recurring First8 Academy presentation about current affairs. This time an overview of the Apache Software Foundation (ASF).
The document summarizes the Devoxx conference, noting that over 5 days, 3,500 attendees from 40 countries participated in the conference along with 200 speakers. An additional 400,000 developers watched presentations online, making Devoxx one of the largest Java conferences. The schedule outlines sessions on various topics each day along with hands-on labs, discussions, and keynotes. Specific sessions are highlighted on topics like Docker, Internet of Things, testing, and more.
Grails GORM - You Know SQL. You Know Queries. Here's GORM.Ted Vinke
This presentation shows practical basics of how Grails Object Relational Mapping (GORM) can help you query data, test it, and think in domain terms along the way when SQL at the moment is all you know.
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...SOFTTECHHUB
The choice of an operating system plays a pivotal role in shaping our computing experience. For decades, Microsoft's Windows has dominated the market, offering a familiar and widely adopted platform for personal and professional use. However, as technological advancements continue to push the boundaries of innovation, alternative operating systems have emerged, challenging the status quo and offering users a fresh perspective on computing.
One such alternative that has garnered significant attention and acclaim is Nitrux Linux 3.5.0, a sleek, powerful, and user-friendly Linux distribution that promises to redefine the way we interact with our devices. With its focus on performance, security, and customization, Nitrux Linux presents a compelling case for those seeking to break free from the constraints of proprietary software and embrace the freedom and flexibility of open-source computing.
Communications Mining Series - Zero to Hero - Session 1DianaGray10
This session provides introduction to UiPath Communication Mining, importance and platform overview. You will acquire a good understand of the phases in Communication Mining as we go over the platform with you. Topics covered:
• Communication Mining Overview
• Why is it important?
• How can it help today’s business and the benefits
• Phases in Communication Mining
• Demo on Platform overview
• Q/A
Unlock the Future of Search with MongoDB Atlas_ Vector Search Unleashed.pdfMalak Abu Hammad
Discover how MongoDB Atlas and vector search technology can revolutionize your application's search capabilities. This comprehensive presentation covers:
* What is Vector Search?
* Importance and benefits of vector search
* Practical use cases across various industries
* Step-by-step implementation guide
* Live demos with code snippets
* Enhancing LLM capabilities with vector search
* Best practices and optimization strategies
Perfect for developers, AI enthusiasts, and tech leaders. Learn how to leverage MongoDB Atlas to deliver highly relevant, context-aware search results, transforming your data retrieval process. Stay ahead in tech innovation and maximize the potential of your applications.
#MongoDB #VectorSearch #AI #SemanticSearch #TechInnovation #DataScience #LLM #MachineLearning #SearchTechnology
Generative AI Deep Dive: Advancing from Proof of Concept to ProductionAggregage
Join Maher Hanafi, VP of Engineering at Betterworks, in this new session where he'll share a practical framework to transform Gen AI prototypes into impactful products! He'll delve into the complexities of data collection and management, model selection and optimization, and ensuring security, scalability, and responsible use.
Sudheer Mechineni, Head of Application Frameworks, Standard Chartered Bank
Discover how Standard Chartered Bank harnessed the power of Neo4j to transform complex data access challenges into a dynamic, scalable graph database solution. This keynote will cover their journey from initial adoption to deploying a fully automated, enterprise-grade causal cluster, highlighting key strategies for modelling organisational changes and ensuring robust disaster recovery. Learn how these innovations have not only enhanced Standard Chartered Bank’s data infrastructure but also positioned them as pioneers in the banking sector’s adoption of graph technology.
Unlocking Productivity: Leveraging the Potential of Copilot in Microsoft 365, a presentation by Christoforos Vlachos, Senior Solutions Manager – Modern Workplace, Uni Systems
How to Get CNIC Information System with Paksim Ga.pptxdanishmna97
Pakdata Cf is a groundbreaking system designed to streamline and facilitate access to CNIC information. This innovative platform leverages advanced technology to provide users with efficient and secure access to their CNIC details.
In the rapidly evolving landscape of technologies, XML continues to play a vital role in structuring, storing, and transporting data across diverse systems. The recent advancements in artificial intelligence (AI) present new methodologies for enhancing XML development workflows, introducing efficiency, automation, and intelligent capabilities. This presentation will outline the scope and perspective of utilizing AI in XML development. The potential benefits and the possible pitfalls will be highlighted, providing a balanced view of the subject.
We will explore the capabilities of AI in understanding XML markup languages and autonomously creating structured XML content. Additionally, we will examine the capacity of AI to enrich plain text with appropriate XML markup. Practical examples and methodological guidelines will be provided to elucidate how AI can be effectively prompted to interpret and generate accurate XML markup.
Further emphasis will be placed on the role of AI in developing XSLT, or schemas such as XSD and Schematron. We will address the techniques and strategies adopted to create prompts for generating code, explaining code, or refactoring the code, and the results achieved.
The discussion will extend to how AI can be used to transform XML content. In particular, the focus will be on the use of AI XPath extension functions in XSLT, Schematron, Schematron Quick Fixes, or for XML content refactoring.
The presentation aims to deliver a comprehensive overview of AI usage in XML development, providing attendees with the necessary knowledge to make informed decisions. Whether you’re at the early stages of adopting AI or considering integrating it in advanced XML development, this presentation will cover all levels of expertise.
By highlighting the potential advantages and challenges of integrating AI with XML development tools and languages, the presentation seeks to inspire thoughtful conversation around the future of XML development. We’ll not only delve into the technical aspects of AI-powered XML development but also discuss practical implications and possible future directions.
Essentials of Automations: The Art of Triggers and Actions in FMESafe Software
In this second installment of our Essentials of Automations webinar series, we’ll explore the landscape of triggers and actions, guiding you through the nuances of authoring and adapting workspaces for seamless automations. Gain an understanding of the full spectrum of triggers and actions available in FME, empowering you to enhance your workspaces for efficient automation.
We’ll kick things off by showcasing the most commonly used event-based triggers, introducing you to various automation workflows like manual triggers, schedules, directory watchers, and more. Plus, see how these elements play out in real scenarios.
Whether you’re tweaking your current setup or building from the ground up, this session will arm you with the tools and insights needed to transform your FME usage into a powerhouse of productivity. Join us to discover effective strategies that simplify complex processes, enhancing your productivity and transforming your data management practices with FME. Let’s turn complexity into clarity and make your workspaces work wonders!
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?Speck&Tech
ABSTRACT: A prima vista, un mattoncino Lego e la backdoor XZ potrebbero avere in comune il fatto di essere entrambi blocchi di costruzione, o dipendenze di progetti creativi e software. La realtà è che un mattoncino Lego e il caso della backdoor XZ hanno molto di più di tutto ciò in comune.
Partecipate alla presentazione per immergervi in una storia di interoperabilità, standard e formati aperti, per poi discutere del ruolo importante che i contributori hanno in una comunità open source sostenibile.
BIO: Sostenitrice del software libero e dei formati standard e aperti. È stata un membro attivo dei progetti Fedora e openSUSE e ha co-fondato l'Associazione LibreItalia dove è stata coinvolta in diversi eventi, migrazioni e formazione relativi a LibreOffice. In precedenza ha lavorato a migrazioni e corsi di formazione su LibreOffice per diverse amministrazioni pubbliche e privati. Da gennaio 2020 lavora in SUSE come Software Release Engineer per Uyuni e SUSE Manager e quando non segue la sua passione per i computer e per Geeko coltiva la sua curiosità per l'astronomia (da cui deriva il suo nickname deneb_alpha).
20 Comprehensive Checklist of Designing and Developing a WebsitePixlogix Infotech
Dive into the world of Website Designing and Developing with Pixlogix! Looking to create a stunning online presence? Look no further! Our comprehensive checklist covers everything you need to know to craft a website that stands out. From user-friendly design to seamless functionality, we've got you covered. Don't miss out on this invaluable resource! Check out our checklist now at Pixlogix and start your journey towards a captivating online presence today.
Maruthi Prithivirajan, Head of ASEAN & IN Solution Architecture, Neo4j
Get an inside look at the latest Neo4j innovations that enable relationship-driven intelligence at scale. Learn more about the newest cloud integrations and product enhancements that make Neo4j an essential choice for developers building apps with interconnected data and generative AI.
A tale of scale & speed: How the US Navy is enabling software delivery from l...sonjaschweigert1
Rapid and secure feature delivery is a goal across every application team and every branch of the DoD. The Navy’s DevSecOps platform, Party Barge, has achieved:
- Reduction in onboarding time from 5 weeks to 1 day
- Improved developer experience and productivity through actionable findings and reduction of false positives
- Maintenance of superior security standards and inherent policy enforcement with Authorization to Operate (ATO)
Development teams can ship efficiently and ensure applications are cyber ready for Navy Authorizing Officials (AOs). In this webinar, Sigma Defense and Anchore will give attendees a look behind the scenes and demo secure pipeline automation and security artifacts that speed up application ATO and time to production.
We will cover:
- How to remove silos in DevSecOps
- How to build efficient development pipeline roles and component templates
- How to deliver security artifacts that matter for ATO’s (SBOMs, vulnerability reports, and policy evidence)
- How to streamline operations with automated policy checks on container images
Pushing the limits of ePRTC: 100ns holdover for 100 daysAdtran
At WSTS 2024, Alon Stern explored the topic of parametric holdover and explained how recent research findings can be implemented in real-world PNT networks to achieve 100 nanoseconds of accuracy for up to 100 days.
6. Immutability in
plain old Java
● final
● final private
● construction in a single step
● defensive copying
● no mutators
● ...
public final class Planet {
private final double mass;
private final String name;
private final Date dateOfDiscovery;
public Planet (double mass, String mame, Date dateOfDiscovery) {
this.mass = mass;
this.name = name;
this.dateOfDiscovery = new Date(dateOfDiscovery.getTime());
}
public double getMass() {
return mass;
}
public String getName() {
return name;
}
public Date getDateOfDiscovery() {
return new Date(dateOfDiscovery.getTime());
}
}
7. Equals, hashCode
in plain-old Java
public final class Location {
private final String countryCode;
private final int priority;
public Location(String countryCode, int priority) {
this.countryCode = countryCode;
this.priority = priority;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((countryCode == null) ? 0 :
countryCode.hashCode());
result = prime * result + priority;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Location))
return false;
Location other = (Location) obj;
if (countryCode == null) {
if (other.countryCode != null)
return false;
} else if (!countryCode.equals(other.countryCode))
return false;
if (priority != other.priority)
return false;
return true;
}
}
10. And...
Dates, Cloneables and arrays are
defensively copied on the way
in (constructor) and out
(getters).
Collections and Maps are wrapped
by immutable wrapper classes.
@Immutable
import groovy.transform.Immutable
@Immutable
class Location {
String countryCode
int priority
}
17. Annotation processing
Lombok, AutoValue, and Immutables all employ annotation processing via
javac, Groovy uses groovyc
AutoValue and Immutables generate new source - which extend template class
e.g. Location.java -> AutoValue_Location.java extends Location
Groovy and Lombok modify the AST and enhances compiled class