This document discusses patterns and pattern languages in object-oriented programming and Java. It describes how patterns connect together to form pattern languages that describe how to build particular systems or solve families of related problems. The document then discusses idioms specific to Java and proposes a pattern language for value-based programming in Java, with patterns like Immutable Value and Factory Method that build on each other to support representing values.
Formal and Computational Representations
The Semantics of First-Order Logic
Event Representations
Description Logics & the Web Ontology Language
Compositionality
Lamba calculus
Corpus-based approaches:
Latent Semantic Analysis
Topic models
Distributional Semantics
French machine reading for question answeringAli Kabbadj
This paper proposes to unlock the main barrier to machine reading and comprehension French natural language texts. This open the way to machine to find to a question a precise answer buried in the mass of unstructured French texts. Or to create a universal French chatbot. Deep learning has produced extremely promising results for various tasks in natural language understanding particularly topic classification, sentiment analysis, question answering, and language translation. But to be effective Deep Learning methods need very large training da-tasets. Until now these technics cannot be actually used for French texts Question Answering (Q&A) applications since there was not a large Q&A training dataset. We produced a large (100 000+) French training Dataset for Q&A by translating and adapting the English SQuAD v1.1 Dataset, a GloVe French word and character embed-ding vectors from Wikipedia French Dump. We trained and evaluated of three different Q&A neural network ar-chitectures in French and carried out a French Q&A models with F1 score around 70%.
Formal and Computational Representations
The Semantics of First-Order Logic
Event Representations
Description Logics & the Web Ontology Language
Compositionality
Lamba calculus
Corpus-based approaches:
Latent Semantic Analysis
Topic models
Distributional Semantics
French machine reading for question answeringAli Kabbadj
This paper proposes to unlock the main barrier to machine reading and comprehension French natural language texts. This open the way to machine to find to a question a precise answer buried in the mass of unstructured French texts. Or to create a universal French chatbot. Deep learning has produced extremely promising results for various tasks in natural language understanding particularly topic classification, sentiment analysis, question answering, and language translation. But to be effective Deep Learning methods need very large training da-tasets. Until now these technics cannot be actually used for French texts Question Answering (Q&A) applications since there was not a large Q&A training dataset. We produced a large (100 000+) French training Dataset for Q&A by translating and adapting the English SQuAD v1.1 Dataset, a GloVe French word and character embed-ding vectors from Wikipedia French Dump. We trained and evaluated of three different Q&A neural network ar-chitectures in French and carried out a French Q&A models with F1 score around 70%.
Introduction to Ontology Engineering with Fluent Editor 2014Cognitum
An introductory course for Ontology Engineering using Controlled Natural Language. Fluent Editor (FE) is an ontology editor that is a tool for editing and manipulating ontologies. The main feature of Fluent Editor is that it uses controlled natural language (CNL) to communicate with a user. Communication with CNL is a more suitable for human users alternative to XML-based OWL editors.
Controlled Natural Language Generation from a Multilingual FrameNet-based Gra...Normunds Grūzītis
We present a currently bilingual but potentially multilingual FrameNet-based grammar library implemented in Grammatical Framework. The contribution of this paper is two-fold. First, it offers a methodological approach to automatically generate the grammar based on semantico-syntactic valence patterns extracted from FrameNet- annotated corpora. Second, it provides a proof of concept for two use cases illustrating how the acquired multilingual grammar can be exploited in different CNL applications in the domains of arts and tourism.
In this talk I intend to review some basic and high-level concepts like formal languages, grammars and ontologies. Languages to transmit knowledge from a sender to a receiver; grammars to formally specify languages; ontologies as formals specifications of specific knowledge domains. After this introductory revision, enhancing the role of each of those elements in the context of computer-based problem solving (programming), I will talk about a project aimed at automatically infer and generate a Grammar for a Domain Specific Language (DSL) from a given ontology that describes this specific domain. The transformation rules will be presented and the system, Onto2Gra, that fully implements that "Ontological approach for DSL development" will be introduced.
A deep analysis of Multi-word Expression and Machine TranslationLifeng (Aaron) Han
A deep analysis of Multi-word Expression and Machine Translation. Faculty research open day. DCU, Dublin. 2019.
Including MWE identification, MT with radical, MTE.
An on-going project on Natural Language Processing (using Python and the NLTK toolkit), which focuses on the extraction of sentiment from a Question and its title on www.stackoverflow.com and determining the polarity.Based on the above findings, it is verified whether the rules and guidelines imposed by the SO community on the users are strictly followed or not.
MORPHOLOGICAL SEGMENTATION WITH LSTM NEURAL NETWORKS FOR TIGRINYAijnlc
Morphological segmentation is a fundamental task in language processing. Some languages, such as
Arabic and Tigrinya,have words packed with very rich morphological information.Therefore, unpacking
this information becomes a necessary taskfor many downstream natural language processing tasks. This
paper presents the first morphological segmentation research forTigrinya. We constructed a new
morphologically segmented corpus with 45,127 manually segmented tokens. Conditional random fields
(CRF) and window-based longshort-term memory (LSTM) neural networkswere employed separately to
develop our boundary detection models. We appliedlanguage-independent character and substring features
for the CRFand character embeddings for the LSTM networks. Experimentswere performed with four
variants of the Begin-Inside-Outside (BIO) chunk annotation scheme. We achieved 94.67% F1 scoreusing
bidirectional LSTMs with fixed-sizewindow approach to morphemeboundary detection.
Introduction to Ontology Engineering with Fluent Editor 2014Cognitum
An introductory course for Ontology Engineering using Controlled Natural Language. Fluent Editor (FE) is an ontology editor that is a tool for editing and manipulating ontologies. The main feature of Fluent Editor is that it uses controlled natural language (CNL) to communicate with a user. Communication with CNL is a more suitable for human users alternative to XML-based OWL editors.
Controlled Natural Language Generation from a Multilingual FrameNet-based Gra...Normunds Grūzītis
We present a currently bilingual but potentially multilingual FrameNet-based grammar library implemented in Grammatical Framework. The contribution of this paper is two-fold. First, it offers a methodological approach to automatically generate the grammar based on semantico-syntactic valence patterns extracted from FrameNet- annotated corpora. Second, it provides a proof of concept for two use cases illustrating how the acquired multilingual grammar can be exploited in different CNL applications in the domains of arts and tourism.
In this talk I intend to review some basic and high-level concepts like formal languages, grammars and ontologies. Languages to transmit knowledge from a sender to a receiver; grammars to formally specify languages; ontologies as formals specifications of specific knowledge domains. After this introductory revision, enhancing the role of each of those elements in the context of computer-based problem solving (programming), I will talk about a project aimed at automatically infer and generate a Grammar for a Domain Specific Language (DSL) from a given ontology that describes this specific domain. The transformation rules will be presented and the system, Onto2Gra, that fully implements that "Ontological approach for DSL development" will be introduced.
A deep analysis of Multi-word Expression and Machine TranslationLifeng (Aaron) Han
A deep analysis of Multi-word Expression and Machine Translation. Faculty research open day. DCU, Dublin. 2019.
Including MWE identification, MT with radical, MTE.
An on-going project on Natural Language Processing (using Python and the NLTK toolkit), which focuses on the extraction of sentiment from a Question and its title on www.stackoverflow.com and determining the polarity.Based on the above findings, it is verified whether the rules and guidelines imposed by the SO community on the users are strictly followed or not.
MORPHOLOGICAL SEGMENTATION WITH LSTM NEURAL NETWORKS FOR TIGRINYAijnlc
Morphological segmentation is a fundamental task in language processing. Some languages, such as
Arabic and Tigrinya,have words packed with very rich morphological information.Therefore, unpacking
this information becomes a necessary taskfor many downstream natural language processing tasks. This
paper presents the first morphological segmentation research forTigrinya. We constructed a new
morphologically segmented corpus with 45,127 manually segmented tokens. Conditional random fields
(CRF) and window-based longshort-term memory (LSTM) neural networkswere employed separately to
develop our boundary detection models. We appliedlanguage-independent character and substring features
for the CRFand character embeddings for the LSTM networks. Experimentswere performed with four
variants of the Begin-Inside-Outside (BIO) chunk annotation scheme. We achieved 94.67% F1 scoreusing
bidirectional LSTMs with fixed-sizewindow approach to morphemeboundary detection.
A Survey of Object Oriented Programming LanguagesMaya Hris.docxdaniahendric
A Survey of Object Oriented Programming Languages
Maya Hristakeva, RadhaKrishna Vuppala
Univ. of California, Santa Cruz
{mayah,vrk}@soe.ucsc.edu
1 Abstract
Object-oriented programming has become a very important programming paradigm of our times.
From the time it was brought into existence by Simula, object-oriented programming has seen wide
acceptance. Object-oriented programming languages (OOPLs) directly support the object notions of
classes, inheritance, information hiding (encapsulation), and dynamic binding (polymorphism). There
is a wide variety of implementations for each of these concepts, and there is no general agreement as to
how a particular concept must be interpreted. This survey takes a detailed look at some of the concepts
considered fundamental to object-orientation, namely inheritance and polymorphism. Different aspects
of inheritance and polymorphism are implemented in various popular OOPLs. We conclude with the
observation that there is still lot of work to be done to reach a common ground for these crucial features
of OOPLs. This survey presents a detailed comparison of Java, C++, C# , Eiffel, Smalltalk, Ruby and
Python in terms of their inheritance and polymorphism implementations. The paper also presents a
compilation of the observations made by several earlier surveys [1, 27].
2 Introduction
There is a big variety of programming languages catering to various kinds of development require-
ments. Three of the main categories are procedural languages (e.g. C, Pascal, etc.), functional languages
(e.g. Haskel, Ocaml, etc.), and object-oriented programming languages (e.g. C++, Java, etc.). The
object-oriented design paradigm has been popular for quite some time owing its success to the powerful
features it offers for making program development easy and robust. OOPLs, such as C++ and Java,
offer an intuitive way of developing programs and provide powerful features for supporting the program
development. While languages like C can be used to develop programs that follow an object-oriented
design, the support of features such as inheritance, encapsulation, strong type support, exception han-
dling, etc. in the OOPLs make them more suitable for such development.
While the object-oriented programming paradigm provides a more intuitive way of programming, it
is also has complexities. This is due to the various complex features that the paradigm offers. OOPLs
differ widely in the way they implement features that are associated with the object design. For example,
some languages support multiple inheritance while some languages consider it a bad feature. In this sur-
vey we discuss the various features of object-oriented programs and how the languages we considered
1
(Java, C++, C# , Eiffel, Smalltalk, Ruby and Python) differ in implementing these features.
The survey is organized as follows. The Section 3 describes in detail the key concepts of OOPLs. Sec-
tion 4 presents a brief historical view of the OOPLs and gives a ...
John Backus identified value-level (object-level) programming languages as programming languages
that combine various values to form other values until the final result values are obtained. Virtually
all our classic programming languages today including C, C++, and Java belong into this category.
Here we identify pattern-level (term-level) programming languages that combine various patterns
to form other patterns until the final result patterns are obtained. New patterns are constructed
from existing ones by the application of pattern-to-pattern functions exploiting pattern matching and
constructors. First-order logic programming languages such as Prolog, OBJ, and Maude belong into
this category. Our insight that pattern-level and value-level programming gives rise to a patternvalue duality is used as the foundation of the design of a new programming language called Asteroid.
Hallmarks of this new programming language design are the developer’s ability to explicitly control
the interpretation or model of expression terms and the notion of ‘patterns as first class citizens’.
In addition to a complete implementation of pattern-level programming Asteroid also supports an
object-oriented style of programming based on prototypes and also subject to pattern matching.
Presentation of "Challenges in transfer learning in NLP" from Madrid Natural Language Processing Meetup Event, May, 2019.
https://www.meetup.com/es-ES/Madrid-Natural-Language-Processing-meetup/
Practical related work in repository: https://github.com/laraolmos/madrid-nlp-meetup
Presented at .NET South West (2024-03-26)
https://www.meetup.com/dotnetsouthwest/events/299766807/
One of the greatest shifts in modern programming practices has been how programmers across many different domains, languages and environments have embraced unit testing. Good unit testing, however, is more than waving NUnit at your C# source. Tests help to make long-term product development cost effective rather than a cost centre, they underpin the effective flow of CI/CD and reduce failure demand on a team.
But the discussion of unit testing goes further than simply writing tests: what makes a good unit test? It is not enough to have tests; poor quality tests can hold back development just as good tests can streamline it. This session provides a perspective on what good unit tests (GUTs) can look like with a couple of examples.
Presented at Agile meets Architecture (2023-10-05)
Video at https://www.youtube.com/watch?v=LLEXAdO3X1o
One of the (most overlooked) principles of the Manifesto for Agile Software Development is that "Continuous attention to technical excellence and good design enhances agility". All too often, work that focuses on addressing technical issues is deprioritised in the name of focusing on business value.
Is there a case for technical excellence — in code, in architecture, in people — beyond its appearance on a might-as-well-be-hidden page on a manifesto that's over two decades old? Is technical excellence only the concern of technical roles? Is a good architecture in conflict with business value or a vehicle for it?
This session looks to go beyond buzzwords to build a case for technical excellence that appeals to all roles in a development organisation, noting that "The best architectures, requirements, and designs emerge from self-organizing teams".
Presented online for Build Stuff meetup (https://www.buildstuff.events/events/online-build-stuff-meetup-with-kevlin-henney-and-cassandra-faris)
Whether we are talking about software architecture, coding practices or our development process, it's important to keep it real. All too often we find ourselves attracted to ideas that sound great in theory, but may not work out in practice. All too often we assume we are right — the planned release schedule, the key architectural decisions, the good practices we saw in a blog — but fail to adjust for reality. We fail to acknowledge that our knowledge was incomplete or that the situation has changed, sticking to the plan and practice regardless.
In this talk we will look at what an empirical approach to development means in practice, why it is that up-front architecture is risky and expensive, why it is that most teams who say they're doing agile development are not, and how we can use uncertainty and instability to structure our time and our code.
Presented online for C++ on Sea (2020-07-17)
Video at https://www.youtube.com/watch?v=Bai1DTcCHVE
Lambdas. All the cool kid languages have them. But does lambda mean what C++ and other languages, from Java to Python, mean by lambda? Where did lambdas come from? What were they originally for? What is their relationship to data abstraction?
In this session we will into the history, the syntax, the uses and abuses of lambdas and the way in which lambda constructs in C++ and other languages do (or do not) match the original construct introduced in lambda calculus.
Presented online for javaBin (2020-04-14)
Video at https://www.youtube.com/watch?v=orcSUE0Jjdc
Lambdas. All the cool kid languages have them. But does ‘lambda’ mean what Java, JavaScript, etc. mean by ‘lambda’? Where did lambdas come from? What were they originally for? What is their relationship to data abstraction?
In this session we will look into the history, the syntax and the uses of lambdas and the way in which lambda constructs in Java and other languages do (or do not) match the original construct introduced in lambda calculus.
Presented at DevSum (2018-05-31)
The SOLID principles are often presented as being core to good code design practice. Each of S, O, L, I and D do not, however, necessarily mean what programmers expect they mean or are taught. By understanding this range of beliefs we can learn more about practices for objects, components and interfaces than just S, O, L, I and D.
This talk reviews the SOLID principles and reveals contradictions and different interpretations. It is through paradoxes and surprises we often gain insights. We will leave SOLID somewhat more fluid, but having learnt from them more than expected.
Presented at Foo Café (2019-03-21)
Video at https://www.youtube.com/watch?v=tLSKLLxrZyY
Programmers use coding katas to kick the tyres of their programming languages, paradigms and practices. Typically anchored in a TDD cycle, katas are simple problems that give programmers the opportunity to exercise deliberate practice and explore different approaches, whether programming style, pair programming or test-first programming.
But the simplicity can be deceptive, with many programmers tiring of these katas too soon, missing out on some of the more mind-bending and paradigm-expanding opportunities on offer.
This session will pick on a couple of katas and dig deeper into TDD, lambdas, language(s), (dys)functional programming and Alcubierre drive. It will present code in a variety of languages, highlight the weaknesses of some common mantras, play around with ideas — and blend code, humour and general nerdiness to be both an enjoyable and educational session.
Procedural Programming: It’s Back? It Never Went AwayKevlin Henney
Presented at ACCU Conference 2018 (2018-04-12)
Video at https://www.youtube.com/watch?v=mrY6xrWp3Gs
When programmers describe code as 'procedural', it’s generally not meant as a compliment. There is a belief that we have collectively moved pass such thinking and onto better paradigms. But a paradigm is no more than a pattern language, a family of solutions fit for a context. Change the kind of problem you are solving and you may find a different solution makes sense — even, in these days where pure functions battle it out with classy objects, procedural programming.
This talk takes a look at some of the past, present and future of procedural programming, looking at how there’s more to it than many first assume, how it has informed and continues to influence language design and how it relates to other paradigms, such as functional and OO.
Structure and Interpretation of Test CasesKevlin Henney
Presented at ACCU Cambridge (2018-10-23)
Throw a line of code into many codebases and it's sure to hit one or more testing frameworks. There's no shortage of frameworks for testing, each with their particular spin and set of conventions, but that glut is not always matched by a clear vision of how to structure and use tests — a framework is a vehicle, but you still need to know how to drive. The computer science classic, Structure and Interpretation of Computer Programs, points out that "Programs must be written for people to read, and only incidentally for machines to execute". The same is true of test code.
This talk takes a deep dive into unit testing, looking at examples and counterexamples across a number of languages and frameworks, from naming to nesting, exploring the benefits of data-driven testing, the trade-offs between example-based and property-based testing, how to get the most out of the common given–when–then refrain and knowing how far to follow it.
Keynote present at Agile Tour Vienna (2018-10-06)
Velocity. Sprints. More points, more speed. An obsession with speed often overtakes the core values of agile software development. It’s not just development of software; it’s development of working software. Sprints are not about sprinting; they’re about sustainable pace. Time to market is less important than time in market. Full-stack development is normally a statement about technology, but it also applies to individuals and interactions. The full stack touches both the code and the world outside the code, and with that view comes responsibility and pause for thought. Doing the wrong thing smarter is not smart. The point of a team is its group intelligence not its numbers. Is scaling up the challenge, or is scaling down the real challenge? The distraction and misuse of speed, velocity, point-based systems, time, team size, scale, etc. is not the accelerant of agile development. Agility lies in experimentation, responsiveness and team intelligence.
Keynote presented at NewCrafts (2018-06-18)
Video available at https://vimeo.com/276832516
It has been said that immutability changes everything. But what does that mean in practice? What does it mean for existing code that looks more like the mutant apocalypse than an elegant application of mathematical thinking? Immutability can be an ideal that is hard to reach. Refactoring, on the other hand, is all about the art of the possible. In this talk we'll be clarifying motivation and exploring some approaches to help reducing state mutability in code.
Keynote presented at GOTO Chicago (2018-04-26)
Video available at https://www.youtube.com/watch?v=AbgsfeGvg3E
Everything is changing. Everything is new. Frameworks, platforms and trends are displaced on a weekly basis. Skills are churning.
And yet... Beneath this seemingly turbulent flow there is a slow current, strong and steady, changing relatively little over the decades. Concepts with a long history appear in new forms and fads and technologies. Principles are revisited. Ideas once lost to the mainstream are found again.
In this keynote we revisit the present through the past, looking at the enduring principles that shape programming languages, architecture, development practice and development process, the ideas that cycle round, each time becoming perhaps a little better defined, a little more mature, and look to see what else might be on the horizon.
Presented at SwanseaCon (2017-09-26)
We default to considering systems from an insider's perspective; the view from outside can be quite different. Can we apply this inversion to more than just requirements?
We may say we want testing, but what do we want from testing? We may say we want logging, but what do we want from logging? We may say we want clean code, but what do we want from clean code? We may say we want an agile process, but what do we want from an agile process? These are harder questions, but their answers can make for better solutions.
Presented at .NET South West (2017-07-25)
Code is basically made up of three things: names, spacing and punctuation. With these three tools a programmer needs to communicate intent, and not simply instruct. But if we look at most approaches to naming, they are based on the idea that names are merely labels, so that discussion of identifier naming becomes little more than a discussion of good labelling.
A good name is more than a label; a good name should change the way the reader thinks. A good name should describe structure with intention, as opposed to the affix-heavy approach common to many naming conventions in current use, where the addition of more prefixes and suffixes becomes homeopathic, diluting the meaning. Good naming is part of good design. This session looks at why and what it takes to get a good name.
Clean Coders Hate What Happens To Your Code When You Use These Enterprise Pro...Kevlin Henney
Presented at code::dive (2016-11-15)
Video available at https://www.youtube.com/watch?v=brfqm9k6qzc
It is all to easy to dismiss problematic codebases on some nebulous idea of bad practice or bad programmers. Poor code, however, is rarely arbitrary and random in its structure or formulation. Systems of code, well or poorly structured, emerge from systems of practice, whether effective or ineffective. To improve code quality, it makes more sense to pick apart the specific practices and see their interplay — the cause — than to simply focus on the code itself — the effect. This talk looks at how a handful of coding habits, design practices and assumptions can systematically balloon code and compound its accidental complexity.
Thinking Outside the Synchronisation QuadrantKevlin Henney
Presented at code::dive (2016-11-16)
Video available at https://www.youtube.com/watch?v=yl25p91flLY
Ask programmers what comes to mind when you say concurrency and most are likely to say threads. Ask what comes to mind when you say threads and most are likely to say locks or synchronisation. These assumptions are so deeply held that they define and constrain how programmers are taught and think about concurrency: thread safety is almost synonymous with the avoidance of race conditions and the guarded protection of mutable state. But this is only one quadrant of four possibilities, a quadrant diagram partitioned by mutable–immutable along one axis and shared–unshared along another. Modern C++ supports programmers in all four quadrants, not just the synchronisation quadrant. From immutability to actors, this talk will take a look at patterns and practices that encourage thinking and coding outside the locked box.
Presented at GOTO Amsterdam (2017-06-13)
Video available at https://www.youtube.com/watch?v=YyhfK-aBo-Y
What is risk? Many people aren't sure, but it's not just uncertainty: risk is exposure to uncertainty.
Instead of just plastering over the cracks, security should also involve reducing the size and number of cracks, reducing the opportunities for cracks to appear, reducing the class of errors and oversights that can open a system to failure instigated from the outside. We can learn a lot from other kinds of software failure, because every failure unrelated to security can be easily reframed as a security-failure opportunity.
This is not a talk about access control models, authentication, encryption standards, firewalls, etc. This is a talk about reducing risk that lives in the code and the assumptions of architecture, reducing the risk in development practices and in the blind spot of development practices.
Keynote presented at SATURN (2nd May 2017)
Video available at https://www.youtube.com/watch?v=MS3c9hz0bRg
"It's just a detail." Have you ever said that or been told that? Whether it's about implementation or requirements, we often use the word detail to suggest that something is not important enough to worry about. There are so many things to worry about in software development that we need to prioritize—too much detail, not enough focus. The problem is that in software, the details matter because that is what software is: lots of details brought together in combination. If we don't focus on the details, we get debt, defects, and delays.
Presented at Agile Bath & Bristol (21st March 2017)
If software development is a co-operative game, as Alistair Cockburn observed, then what kind of game is Scrum? Lots of people are playing it — or say they are — but there seems to be some disagreement about what the point of the game is, how to play it and even, in many cases, what the rules are. This talk looks at Scrum and other agile approaches through the lens of nomic games, hypothesis-driven development and fun.
Presented at the European Bioinformatics Institute (17th March 2017)
We often talk about good code — that we would like to write it, that there isn't enough of it, that it should not be considered an optional attribute of a codebase. We often talk about it but, when it comes to being precise, we don't always agree what constitutes good code, nor do we necessarily share a common view on its value.
Developing Distributed High-performance Computing Capabilities of an Open Sci...Globus
COVID-19 had an unprecedented impact on scientific collaboration. The pandemic and its broad response from the scientific community has forged new relationships among public health practitioners, mathematical modelers, and scientific computing specialists, while revealing critical gaps in exploiting advanced computing systems to support urgent decision making. Informed by our team’s work in applying high-performance computing in support of public health decision makers during the COVID-19 pandemic, we present how Globus technologies are enabling the development of an open science platform for robust epidemic analysis, with the goal of collaborative, secure, distributed, on-demand, and fast time-to-solution analyses to support public health.
Check out the webinar slides to learn more about how XfilesPro transforms Salesforce document management by leveraging its world-class applications. For more details, please connect with sales@xfilespro.com
If you want to watch the on-demand webinar, please click here: https://www.xfilespro.com/webinars/salesforce-document-management-2-0-smarter-faster-better/
Climate Science Flows: Enabling Petabyte-Scale Climate Analysis with the Eart...Globus
The Earth System Grid Federation (ESGF) is a global network of data servers that archives and distributes the planet’s largest collection of Earth system model output for thousands of climate and environmental scientists worldwide. Many of these petabyte-scale data archives are located in proximity to large high-performance computing (HPC) or cloud computing resources, but the primary workflow for data users consists of transferring data, and applying computations on a different system. As a part of the ESGF 2.0 US project (funded by the United States Department of Energy Office of Science), we developed pre-defined data workflows, which can be run on-demand, capable of applying many data reduction and data analysis to the large ESGF data archives, transferring only the resultant analysis (ex. visualizations, smaller data files). In this talk, we will showcase a few of these workflows, highlighting how Globus Flows can be used for petabyte-scale climate analysis.
Understanding Globus Data Transfers with NetSageGlobus
NetSage is an open privacy-aware network measurement, analysis, and visualization service designed to help end-users visualize and reason about large data transfers. NetSage traditionally has used a combination of passive measurements, including SNMP and flow data, as well as active measurements, mainly perfSONAR, to provide longitudinal network performance data visualization. It has been deployed by dozens of networks world wide, and is supported domestically by the Engagement and Performance Operations Center (EPOC), NSF #2328479. We have recently expanded the NetSage data sources to include logs for Globus data transfers, following the same privacy-preserving approach as for Flow data. Using the logs for the Texas Advanced Computing Center (TACC) as an example, this talk will walk through several different example use cases that NetSage can answer, including: Who is using Globus to share data with my institution, and what kind of performance are they able to achieve? How many transfers has Globus supported for us? Which sites are we sharing the most data with, and how is that changing over time? How is my site using Globus to move data internally, and what kind of performance do we see for those transfers? What percentage of data transfers at my institution used Globus, and how did the overall data transfer performance compare to the Globus users?
Enterprise Resource Planning System includes various modules that reduce any business's workload. Additionally, it organizes the workflows, which drives towards enhancing productivity. Here are a detailed explanation of the ERP modules. Going through the points will help you understand how the software is changing the work dynamics.
To know more details here: https://blogs.nyggs.com/nyggs/enterprise-resource-planning-erp-system-modules/
Utilocate offers a comprehensive solution for locate ticket management by automating and streamlining the entire process. By integrating with Geospatial Information Systems (GIS), it provides accurate mapping and visualization of utility locations, enhancing decision-making and reducing the risk of errors. The system's advanced data analytics tools help identify trends, predict potential issues, and optimize resource allocation, making the locate ticket management process smarter and more efficient. Additionally, automated ticket management ensures consistency and reduces human error, while real-time notifications keep all relevant personnel informed and ready to respond promptly.
The system's ability to streamline workflows and automate ticket routing significantly reduces the time taken to process each ticket, making the process faster and more efficient. Mobile access allows field technicians to update ticket information on the go, ensuring that the latest information is always available and accelerating the locate process. Overall, Utilocate not only enhances the efficiency and accuracy of locate ticket management but also improves safety by minimizing the risk of utility damage through precise and timely locates.
First Steps with Globus Compute Multi-User EndpointsGlobus
In this presentation we will share our experiences around getting started with the Globus Compute multi-user endpoint. Working with the Pharmacology group at the University of Auckland, we have previously written an application using Globus Compute that can offload computationally expensive steps in the researcher's workflows, which they wish to manage from their familiar Windows environments, onto the NeSI (New Zealand eScience Infrastructure) cluster. Some of the challenges we have encountered were that each researcher had to set up and manage their own single-user globus compute endpoint and that the workloads had varying resource requirements (CPUs, memory and wall time) between different runs. We hope that the multi-user endpoint will help to address these challenges and share an update on our progress here.
Top 7 Unique WhatsApp API Benefits | Saudi ArabiaYara Milbes
Discover the transformative power of the WhatsApp API in our latest SlideShare presentation, "Top 7 Unique WhatsApp API Benefits." In today's fast-paced digital era, effective communication is crucial for both personal and professional success. Whether you're a small business looking to enhance customer interactions or an individual seeking seamless communication with loved ones, the WhatsApp API offers robust capabilities that can significantly elevate your experience.
In this presentation, we delve into the top 7 distinctive benefits of the WhatsApp API, provided by the leading WhatsApp API service provider in Saudi Arabia. Learn how to streamline customer support, automate notifications, leverage rich media messaging, run scalable marketing campaigns, integrate secure payments, synchronize with CRM systems, and ensure enhanced security and privacy.
How to Position Your Globus Data Portal for Success Ten Good PracticesGlobus
Science gateways allow science and engineering communities to access shared data, software, computing services, and instruments. Science gateways have gained a lot of traction in the last twenty years, as evidenced by projects such as the Science Gateways Community Institute (SGCI) and the Center of Excellence on Science Gateways (SGX3) in the US, The Australian Research Data Commons (ARDC) and its platforms in Australia, and the projects around Virtual Research Environments in Europe. A few mature frameworks have evolved with their different strengths and foci and have been taken up by a larger community such as the Globus Data Portal, Hubzero, Tapis, and Galaxy. However, even when gateways are built on successful frameworks, they continue to face the challenges of ongoing maintenance costs and how to meet the ever-expanding needs of the community they serve with enhanced features. It is not uncommon that gateways with compelling use cases are nonetheless unable to get past the prototype phase and become a full production service, or if they do, they don't survive more than a couple of years. While there is no guaranteed pathway to success, it seems likely that for any gateway there is a need for a strong community and/or solid funding streams to create and sustain its success. With over twenty years of examples to draw from, this presentation goes into detail for ten factors common to successful and enduring gateways that effectively serve as best practices for any new or developing gateway.
Exploring Innovations in Data Repository Solutions - Insights from the U.S. G...Globus
The U.S. Geological Survey (USGS) has made substantial investments in meeting evolving scientific, technical, and policy driven demands on storing, managing, and delivering data. As these demands continue to grow in complexity and scale, the USGS must continue to explore innovative solutions to improve its management, curation, sharing, delivering, and preservation approaches for large-scale research data. Supporting these needs, the USGS has partnered with the University of Chicago-Globus to research and develop advanced repository components and workflows leveraging its current investment in Globus. The primary outcome of this partnership includes the development of a prototype enterprise repository, driven by USGS Data Release requirements, through exploration and implementation of the entire suite of the Globus platform offerings, including Globus Flow, Globus Auth, Globus Transfer, and Globus Search. This presentation will provide insights into this research partnership, introduce the unique requirements and challenges being addressed and provide relevant project progress.
Top Features to Include in Your Winzo Clone App for Business Growth (4).pptxrickgrimesss22
Discover the essential features to incorporate in your Winzo clone app to boost business growth, enhance user engagement, and drive revenue. Learn how to create a compelling gaming experience that stands out in the competitive market.
Cyaniclab : Software Development Agency Portfolio.pdfCyanic lab
CyanicLab, an offshore custom software development company based in Sweden,India, Finland, is your go-to partner for startup development and innovative web design solutions. Our expert team specializes in crafting cutting-edge software tailored to meet the unique needs of startups and established enterprises alike. From conceptualization to execution, we offer comprehensive services including web and mobile app development, UI/UX design, and ongoing software maintenance. Ready to elevate your business? Contact CyanicLab today and let us propel your vision to success with our top-notch IT solutions.
Quarkus Hidden and Forbidden ExtensionsMax Andersen
Quarkus has a vast extension ecosystem and is known for its subsonic and subatomic feature set. Some of these features are not as well known, and some extensions are less talked about, but that does not make them less interesting - quite the opposite.
Come join this talk to see some tips and tricks for using Quarkus and some of the lesser known features, extensions and development techniques.
In software engineering, the right architecture is essential for robust, scalable platforms. Wix has undergone a pivotal shift from event sourcing to a CRUD-based model for its microservices. This talk will chart the course of this pivotal journey.
Event sourcing, which records state changes as immutable events, provided robust auditing and "time travel" debugging for Wix Stores' microservices. Despite its benefits, the complexity it introduced in state management slowed development. Wix responded by adopting a simpler, unified CRUD model. This talk will explore the challenges of event sourcing and the advantages of Wix's new "CRUD on steroids" approach, which streamlines API integration and domain event management while preserving data integrity and system resilience.
Participants will gain valuable insights into Wix's strategies for ensuring atomicity in database updates and event production, as well as caching, materialization, and performance optimization techniques within a distributed system.
Join us to discover how Wix has mastered the art of balancing simplicity and extensibility, and learn how the re-adoption of the modest CRUD has turbocharged their development velocity, resilience, and scalability in a high-growth environment.
How Recreation Management Software Can Streamline Your Operations.pptxwottaspaceseo
Recreation management software streamlines operations by automating key tasks such as scheduling, registration, and payment processing, reducing manual workload and errors. It provides centralized management of facilities, classes, and events, ensuring efficient resource allocation and facility usage. The software offers user-friendly online portals for easy access to bookings and program information, enhancing customer experience. Real-time reporting and data analytics deliver insights into attendance and preferences, aiding in strategic decision-making. Additionally, effective communication tools keep participants and staff informed with timely updates. Overall, recreation management software enhances efficiency, improves service delivery, and boosts customer satisfaction.
OpenFOAM solver for Helmholtz equation, helmholtzFoam / helmholtzBubbleFoamtakuyayamamoto1800
In this slide, we show the simulation example and the way to compile this solver.
In this solver, the Helmholtz equation can be solved by helmholtzFoam. Also, the Helmholtz equation with uniformly dispersed bubbles can be simulated by helmholtzBubbleFoam.
OpenFOAM solver for Helmholtz equation, helmholtzFoam / helmholtzBubbleFoam
Patterns of Value
1. 64 Java™
Report | F E BR UA R Y 20 0 0 http://www.java re po rt.com
WHAT IS AN object worth? For that
matter, what is a pattern worth? The
answer to both of these questions is:
not much. At least, not on their own.
Object-oriented (OO) systems work because the
behavior and information of the system is distrib-
uted across a network of connected objects, each
responsible for a particular part of the system's
behavior and/or information, their granularity rang-
ing from the large to the small. The references con-
necting objects together may be held for the lifetime
of an object, or for less than the duration of a method
call. In execution the
threads of control ripple
through and affect this
network.
A similar thing can be
said of patterns: Patterns
do not exist in isolation
only solving individual
design problems at a sin-
gle level. Patterns can be
collected together for
common use, but more
powerfully they can be
connected together as a
pattern language to describe how to build a
particular kind of system or resolve a family of
related problems.
Putting Patterns in Their Place
The Gang of Four (GoF) catalog of design patterns1
col-
lects a number of general purpose patterns for use in
OO design. However, it is certainly not the last word
on either patterns or design. Design embraces many
levels of detail in a system, from its gross architecture
right down to the use of language features; design
must also relate to the purpose as well as the mecha-
nism of the system.
Pattern-Oriented Software Architecture (POSA)2
is another catalog that is in many ways GoF-like. One
way in which it goes further than GoF is in classify-
ing its patterns as belonging to one of three levels:
architecture, by which the gross architecture is
meant; design, by which detailed design at the same
level of GoF is intended; and idioms, which focus on
programming language-specific patterns.
Idioms
As anyone who has studied a language at school only
to be left—literally— speechless when visiting some-
where it is spoken natively will know, understanding
of any language goes beyond a by rote knowledge of
syntax and semantics. Fluency in a language is also
about embracing its idioms and expressing yourself
appropriately in that language with intention, rather
than by accident or by dogma. This is as true of pro-
gramming languages as it is of natural languages, and
Java presents a context of mechanisms and common
practices for design to incorporate.
Many idioms can be seen to define conventions of
style, e.g., class and method naming conventions.
Others have a more direct relationship to patterns.
Where patterns are considered to be solutions to
problems occurring in a context, many idioms are
language-level or technology-specific patterns3
; that
is, they have the language or technology as part of
their context.
Parts of Java's context that affects how design
decisions are taken include its strong typing, reflec-
tion, support for multithreading, garbage collection,
and reference-based objects. This context leads Java
developers down different routes than those taken
by either C++ or Smalltalk developers. For instance,
much of the detail describing C++ issues such as
memory management in Design Patterns1
is not rel-
evant in Java. At the same time, there are Java issues
of interest that are not explored. So, some idioms
may adapt general design patterns to fit in more
appropriately with the language, as was done with
the Design Patterns Smalltalk Companion,4
which
expresses and discusses the GoF patterns in a more
idiomatic form for Smalltalk programmers.
Idioms may also represent design decisions that
exist only in that language. Note that not all lan-
Patterns of Value
Kevlin Henney is a Principal Technologist with QA Training
in the UK.
KevlinHenney/ khenney@qatraining.com
Patterns in Java
2. 65http://www.java re po rt.com F EB R UA R Y 2 00 0 | Java™
Report
guage-specific conventions warrant the name patterns.
For instance, the JavaBeans naming conventions—get*
and set*, etc.—are just that: naming conventions. They
define framework participation rules, to support mean-
ingful introspection, for non-BeanInfo implementers.
Therefore, although idiomatic in one sense, they are not
patterns in the sense we are talking about. When the
authors of the JavaBeans specification called the naming
convention design patterns, they confused regular
expression pattern matching with the more specific con-
cept of design patterns.
Java idioms are being documented in a number of
places, including a growing body of tentative idioms on
the Wiki.5
In some cases the patterns have a more specif-
ic context than simply Java, for instance, dealing with
concurrency.6
Pattern Languages
Patterns often have relationships with other patterns. The
related patterns may be used to resolve problems in the
new context introduced by applying a particular pattern,
or patterns may be used to support the development of a
particular solution. For instance, Iterator is often support-
ed by the use of a Factory Method.1
Patterns can be grouped together and collected in a
catalog to provide a useful knowledge source; a simple
software engineering handbook if you like, e.g., GoF
and POSA. There may be some documented relation-
ships between the patterns in a catalog. However,
the value of patterns is more fully realized when con-
necting them together in the narrative framework of a
pattern language3
:
A pattern language is a collection of patterns that
build on each other to generate a system. A pattern in
isolation solves an isolated design problem; a pattern
language builds a system. It is through pattern languages
that patterns achieve their fullest power.…A pattern lan-
guage should not be confused with a programming lan-
guage. A pattern language is a piece of literature that
describes an architecture, a design, a framework, or
other structure. It has structure, but not the same level
of formal structure that one finds in programming
languages.
A pattern language represents a reasonable set of prac-
tices and decisions that need to be taken together to
resolve a particular design challenge. The relationships
help the developer determine which patterns should be
applied and under what circumstances. The developer
works with a connected group of patterns rather than just
individual patterns.
The idea of pattern languages originated with patterns
in building architecture7
, but there are now many good
examples for software, for instance, in the Pattern
Language of Program Design books.8–10
There is even a pat-
tern language for writing pattern languages!11
Value-Based Programming
What kind of problem in Java needs the concerted col-
laboration of many patterns? There are many, but to give
you a simple and complete example that we can work
through in this and the next column, let us consider the
issue of expressing and using values in Java. Examples
of value types include strings, integers, and intervals, as
well as semantically richer dates, money, and physical
quantities such as length, mass, and time. We often
think of objects as representing the significant chunks of
a system; values, in effect, form the currency between
these chunks.
Identity, State, and Behavior
An object can be characterized by identity, state, and
behavior.12
Value objects have transparent identity, sig-
nificant state, and behavior directly related to the state.
Knowing the identity of an object means that you can
hold a reference to it. By transparent identity we mean
that a value object's identity is not important to the way
we use it, and one value object is substitutable for anoth-
er with the same state. An example of this is a string. Our
Figure 1. Patterns and their successors for supporting value-based programming in Java.
78
Patterns in Java / Kevlin Henney
WHOLE
VALUE
IMMUTABLE
VALUE
MUTABLE
COMPANION
VALUE
CLASS
CLASS FACTORY
METHOD
CLONEABLE
VALUE
ENUMARATION
VALUES
3. focus is on a string's content and its manipulation, and
not on the reference itself: Comparison of the content of
two strings is of interest, but comparison of their identi-
ty is less useful. In other words, common usage for String
is based on its overridden equals method and not on
the == operator.
Service-based objects are another example where iden-
tity is incidental. However, for service objects behavior
and not state is the most important feature; often service
objects are stateless. Contrast this with entity objects, for
which both identity and state are significant.
Values in Java
Except for the built-in types, such as int, Java currently
supports only reference-based objects. Interesting propos-
als for language extension aside,13
it is not currently possi-
ble for developers to create their own types to follow the
same behavior as the built-ins. For instance, there is no
operator overloading in Java, except for the indirect rela-
tionship between the + operator and the toString method,
and passing by copy is supported only in the context of
remoting, specifically java.io.Serializable types under RMI.
Nonetheless, this does not remove the need for devel-
opers to create types that act as values. The idioms for
supporting fine-grained value types can be described
through a pattern language.
A Pattern Language
The pattern language for value-based programming in Java
that follows is a work in progress. It is drawn from com-
mon Java practices as found in published code, including
the standard Java libraries. A summary and basic structure
of the language, followed by a simple example that
demonstrates its use, is shown this time. In the next col-
umn we will examine each of the patterns in more detail.
Overview of the Patterns
Figure 1 shows all of the patterns in the language. Lines
with arrows represent successor relationships, showing
how one pattern may be followed by another to support it
in some way; the detail of that support is found in the text
of the pattern itself.
An Immutable Value, for example, avoids the side-effect
problems that arise from sharing value objects between
objects, particularly across threads. However, it can be
costly and awkward, in terms of object creation, to only
66 Java™
Report | FE BR UAR Y 2 0 00 http://www.java re po rt.com
Patterns in Java / Kevlin Henney
Name Problem Solution
Class Factory Method How can you simplify,and potentially Provide static methods to be used instead of (or
optimize,construction of Value Class as well as) ordinary constructors.The methods
objects in expressions without return either newly created Value Class objects
resorting to intrusive new expressions? or cached objects from a table.
Cloneable Value How can you pass a Value Class object Implement the Cloneable interface for the Value
into and out of methods without Class and use a clone of the original whenever
allowing callers or called methods to it needs to be passed.
affect the original object?
Enumeration Values How can you represent a fixed set Each constant is represented by an Immutable
of constant values and preserve Value defined as a static final in the scope of the
type safety? Immutable Value class,which cannot be
instantiated outside the scope of that class.
Immutable Value How can you share Value Class Set the internal state of the Value Class object
objects and guarantee no side- at construction,and allow no subsequent
effect problems? modifications i.e.,implement only query methods.
Mutable Companion How can you simplify complex Implement a companion class that supports
construction of an Immutable Value? modifier methods and acts as a factory for
Immutable Value objects.
Value Class How do you define a class to Override the methods in Object whose action
represent values in your system? should be related to content and not identity
(e.g.,equal), and implement Serializable.The
Value Class will be either an Immutable Value or a
Cloneable Value.Simplify construction with a Class
Factory Method.
Whole Value How can you represent a primitive Express the type of the quantity as a Value Class.
domain quantity in your system
without loss of meaning?
Table1. Thumbnails for value-based programming patterns.
4. 68 Java™
Report | FE BR UAR Y 2 0 0 0 http://www.java re po rt.com
Patterns in Java / Kevlin Henney
work with Immutable Value objects, and so it is often help-
ful to provide a Mutable Companion class for the
Immutable Value class. In the standard Java library,
java.lang.StringBuffer is an Immutable Value and java.
lang.StringBuffer is a Mutable Companion.
Table 1 summarizes each of the patterns alphabetically
in what is commonly known as thumbnail form: The
name, essential problem, and brief solution are presented
without rationale or examples.
Putting the Patterns to Work
A simple example can be used to illustrate the pattern lan-
guage in action. Consider the problem of representing
dates in an object system. The resulting code is shown in
Listing 1 (available online in the code section of
www.javareport.com ).
The Whole Value pattern,14
also known as the Quantity
pattern,15
and Value Class pattern offer the entry points into
the pattern language. We can already guess that the best
way to represent dates in our systems is directly as objects,
hence the need for a class Date. The way in which Date
should be implemented is as a Value Class, which describes
what is involved in making its instances value-like.
A Date object is considered to be an Immutable Value16
to avoid problems arising from sharing a single Date
object among other objects. For instance, two objects
sharing a Date object expect that the value it represents
should remain unchanged. However, if one of the objects
modifies it, the other will also experience the change—a
person object holding a date of birth field may unexpect-
edly find its birthday moved! To simplify manipulation
of dates Mutable Companion, DateManipulator, is also pro-
vided. An alternative to this approach is to make Date a
Cloneable Value.
One issue that needs to be addressed is what field order
should be used to initialize Date objects: YYYY/MM/DD,
DD/MM/YYYY, or MM/DD/YYYY? The joy of standards
is that there are so many to choose from, but if we choose
one how do we enforce that choice? If int is used to repre-
sent the year, the month, and the day, there is no type
checking to catch incorrect use of the other cases, e.g.,
given the following constructor:
public class Date implements Serializable
{
public Date(int year, int month, int day) ...
...
}
All of the following will compile:
Date right = new Date(year, month, day);
Date wrong = new Date(day, month, year);
Date alsoWrong = new Date(month, day, year);
Months can be conveniently represented as Enumeration
Values, also known as Typesafe Constant,17
which deals
with expressing fixed sets of constants (think enum in C
and C++). A year can be conveniently wrappered as a
Whole Value, making it a distinct type and therefore
checked by the type system. The Year class is intended
for use as part of a method's interface rather than as part
of an object's representation; it is at the interface that the
type safety is really needed. Given that Month and Year
are now checked, it is safe to leave the day in the month
as a plain int, although you may wish to make it a Whole
Value for consistency.
The Class Factory Method pattern generally supports
the Value Class pattern, making it easier to express new
objects in expressions, as in the case of Year. The Class
Factory Method pattern is a more specific variant of the
Factory Method1
pattern: Factory Method deals specifically
with managing object creation in a class hierarchy,
Class Factory Method focuses on providing an alternative
method of object creation to calling new with a
constructor.
Conclusion
Patterns are gregarious: They like company, and can work
well with other patterns to assist in design. The simple
issue resolved here, that of value-based programming in
Java, hopefully illustrates how a pattern language com-
bines patterns to work through a problem and support a
set of principles. Next time, we will look at each of the
patterns in greater detail. s
References
1. Gamma, E., et al., Design Patterns: Elements of Reusable
Object-Oriented Software, Addison–Wesley, 1995.
2. Buschmann, F., et al., Pattern-Oriented Software
Architecture: A System of Patterns, Wiley, 1996.
3. Coplien, J., Software Patterns, SIGS, 1996.
4. Alpert, S., Brown, K., Woolf, B., The Design Patterns
Smalltalk Companion, Addison–Wesley, 1998.
5. Java Idioms, http://c2.com/cgi/wiki.
6. Lea, D., Concurrent Programming in Java: Design
Principles and Patterns, Addison–Wesley, 1999.
7. Alexander, C., et al., A Pattern Language: Towns,
Buildings, Construction, Oxford University Press, 1977.
8. Coplien, J. and D. Schmidt, Eds., Pattern Languages of
Program Design, Addison–Wesley, 1995.
9. Vlissides, J., J. Coplien, and N. Kerth, Eds., Pattern
Languages of Program Design 2, Addison–Wesley, 1996.
10. Martin, R., D. Riehle, and F. Buschmann, Eds., Pattern
Languages of Program Design 3, Addison–Wesley, 1998.
11. Meszaros, G., Doble, J., "A Pattern Language for Writing
Pattern Writing," PLoPD1998.
12. Booch, G., Object-Oriented Analysis and Design with
Applications, 2nd edition, Benjamin/Cummings, 1994.
13. Gosling, J., "The Evolution of Numerical Computing in
Java," http://java.sun.com/people/jag/FP.html.
14. Cunningham, W., "The CHECKS Pattern Language of
Information Integrity," PLoPD1995.
15. Fowler, M., Analysis Patterns: Reusable Object Models,
Addison–Wesley, 1997.
16. Henney, K., "Java Patterns and Implementations,"
presented at BCS OOPS Patterns Day, Oct. 1997,
presentation notes and whitepaper,
techland.qatraining.com/profile.htm.
17. Warren, N., Bishop, P., Java in Practice: Design Styles
and Idioms for Effective Java, Addison–Wesley, 1999.