Presented at ACCU Conference (11th April 2014)
"When it is not necessary to change, it is necessary not to change" observed Lucius Cary, four centuries ago. He could well have been talking about program state (had such a concept existed). We have it by the bucket — by the megabucket, gigabucket and terabucket — and most code, designs and programming languages assume that program state is something that is changeable. But should it? Is this assumption always valid? Is state change as necessary as its widespread use might suggest?
Immutability is a cornerstone of pure functional programming, and is often seen to be exclusively associated with it, but immutability and other restrictions on state mutability are more widely applicable, and certainly not the sole preserve of functional languages. It is a necessary practice in languages with reference-based semantics and in concurrent environments, for example. Without it, code becomes difficult to reason about (oh...) or chock full of locks and deadlocks (ah...). This loss of simplicity may seem familiar.
This talk looks at the consequences, benefits and implications of programming in an immutable or less mutable style, including techniques both large and small that can be applied in mainstream languages and existing systems.
Presented at GOTO Amsterdam (20th June 2014)
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 slightly more fluid, but having learnt from them more than expected.
Presented at GOTO Nights (20th September 2016)
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 NDC London (5th December 2014)
Ralph Johnson defined architecture as "the decisions that you wish you could get right early in a project, but that you are not necessarily more likely to get them right than any other". Given our inability to tell the future how can we design effectively for it? Much project management thinking is based on the elimination of uncertainty, and advice on software architecture and guidance for future-proofing code often revolves around adding complexity to embrace uncertainty. In most cases, this is exactly the opposite path to the one that should be taken.
The talk looks at how uncertainty, lack of knowledge and options can be used to partition and structure the code in a system.
الأستاذ والشيخ حسنين الديب ( رحمه الله )
الإسم/ حسنين محمد خليل الديب.
*****
الشهرة/ الشيخ حسنين الديب.
******
الميلاد/1928 م .
******
محل الميلاد/ إدفو – الغنيمية.
**********
التعليم والدراسة:
*************
- حفظ القرأن فى كتاب القرية على يد (الشيخ/ محمود خليفة).
- ذهب إلى القاهرة للتعليم والدراسة بالجامع الأزهر بصحبة أحد إخوته منتصف أربعينيات القرن الــ20 الميلادى عام (1945م).
- إلتحق بكلية أصول الدين بالأزهر وتخرج منها عام 1955م.
العمل والمهنة:
**********
- عمل فى بداية حياته بمدرساً بمعهد قنـا الأزهرى ،ثم انتقل للتدريس بمعهد أســوان
الأزهرى.
- عمل مدرساً بمعاهد القراءات بمحافظة أســوان.
- عمل موجهاً بالتعليم الإبتدائى عام 1974م .
- أُحيل للمعاش عام 1989م.
نشاط الدعوة الدينية والخطابة:
***********************
- كان خطيباً با رعاً .
- امتاز يالميول الصوفية وحب أل بيت رسول الله ﷺ.
وفاته: توفى مساء الأحد ( 18- 8 -1997 م).
له من الأبناء:
**********
+ صلاح الد ين ◄► طبيب بشرى وأخصائى جلد ية وتناسلية .
+ كمال ◄► موظف بإدارة إد فو التعليمية.
+ أحمد◄► صيد لى بإدفو.
+ عبد الله ◄►صيد لى بالمملكة العربية السعودية.
+ محمد◄► محاسب بشركة المحطات المائية لإنتاج الكهرباء بأسوان.
+ له بناتان (لم تود الأسرة الإفصاح عنهم).
#رحم_الله_هذا_الرجل_فقد_حفظ_كتاب_الله_ودرس_أصول_الدين
#وكان_خطيباً_بارعاً_رغم_فقده_لبصره
A brief overview of Tapit and what we do. If you want to find out how you can use Tapit please feel free to drop us a line at contact@tapit.com.au.
To see live demos of Tapit in action visit our YouTube channel at www.youtube.com/tapitnfc
Presented at GOTO Amsterdam (20th June 2014)
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 slightly more fluid, but having learnt from them more than expected.
Presented at GOTO Nights (20th September 2016)
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 NDC London (5th December 2014)
Ralph Johnson defined architecture as "the decisions that you wish you could get right early in a project, but that you are not necessarily more likely to get them right than any other". Given our inability to tell the future how can we design effectively for it? Much project management thinking is based on the elimination of uncertainty, and advice on software architecture and guidance for future-proofing code often revolves around adding complexity to embrace uncertainty. In most cases, this is exactly the opposite path to the one that should be taken.
The talk looks at how uncertainty, lack of knowledge and options can be used to partition and structure the code in a system.
الأستاذ والشيخ حسنين الديب ( رحمه الله )
الإسم/ حسنين محمد خليل الديب.
*****
الشهرة/ الشيخ حسنين الديب.
******
الميلاد/1928 م .
******
محل الميلاد/ إدفو – الغنيمية.
**********
التعليم والدراسة:
*************
- حفظ القرأن فى كتاب القرية على يد (الشيخ/ محمود خليفة).
- ذهب إلى القاهرة للتعليم والدراسة بالجامع الأزهر بصحبة أحد إخوته منتصف أربعينيات القرن الــ20 الميلادى عام (1945م).
- إلتحق بكلية أصول الدين بالأزهر وتخرج منها عام 1955م.
العمل والمهنة:
**********
- عمل فى بداية حياته بمدرساً بمعهد قنـا الأزهرى ،ثم انتقل للتدريس بمعهد أســوان
الأزهرى.
- عمل مدرساً بمعاهد القراءات بمحافظة أســوان.
- عمل موجهاً بالتعليم الإبتدائى عام 1974م .
- أُحيل للمعاش عام 1989م.
نشاط الدعوة الدينية والخطابة:
***********************
- كان خطيباً با رعاً .
- امتاز يالميول الصوفية وحب أل بيت رسول الله ﷺ.
وفاته: توفى مساء الأحد ( 18- 8 -1997 م).
له من الأبناء:
**********
+ صلاح الد ين ◄► طبيب بشرى وأخصائى جلد ية وتناسلية .
+ كمال ◄► موظف بإدارة إد فو التعليمية.
+ أحمد◄► صيد لى بإدفو.
+ عبد الله ◄►صيد لى بالمملكة العربية السعودية.
+ محمد◄► محاسب بشركة المحطات المائية لإنتاج الكهرباء بأسوان.
+ له بناتان (لم تود الأسرة الإفصاح عنهم).
#رحم_الله_هذا_الرجل_فقد_حفظ_كتاب_الله_ودرس_أصول_الدين
#وكان_خطيباً_بارعاً_رغم_فقده_لبصره
A brief overview of Tapit and what we do. If you want to find out how you can use Tapit please feel free to drop us a line at contact@tapit.com.au.
To see live demos of Tapit in action visit our YouTube channel at www.youtube.com/tapitnfc
Minder jaar voor firma van Marcel VanthiltThierry Debels
De vennootschap van Marcel Vanthilt heeft de jaarrekening over 2015 neergelegd.
Het jaar 2015 was een minder goed jaar met een verlies van ruim 28.000 euro. In 2014 was er nog een winst van bijna 25.000 euro.
Портрет аудитории (соц-дем характеристики) самых популярный сайтов РМ. Сентябрь 2016
Profilul socio-demografic al audientei site-urilor din RM. Septembrie 2016
Disampaikan pada Rapat Koordinasi Wilayah IV
Asosiasi Pemerintah Kota Seluruh Indonesia (APEKSI) ke-12
DENPASAR, 2 Juni 2016
Dr. Tri Widodo W. Utomo, MA
Deputi Inovasi Administrasi Negara/
Plt. Deputi Kajian Kebijakan LAN-RI
http://inovasi.lan.go.id
Understanding The Bible Part Five Psalms, Isaiah, Tobit, Judith, and EstherEdward Hahnenberg
Part Five presents the classification of Psalms as well as the possible borrowing of textual material from the Ugaritic culture. The Book of Isaiah is discussed as three separate texts with three different authors. Also discussed are the Books of Tobit, Judith, and Esther.
Presented at DevWeek (24th March 2015)
Although not yet fully mainstream, functional programming has finally reached a critical mass of awareness among developers. The problem, however, is that many developers are up against an even greater critical mass of existing code. Much of this code purports to be object oriented, but beyond the use of the class keyword, falls somewhat short of putting the OO to good use.
Many techniques identified as functional have broader applicability. This session will explore how some FP habits can be incorporated into OOP practice.
This is a friendly Lambda Calculus Introduction by Dustin Mulcahey. LISP has its syntactic roots in a formal system called the lambda calculus. After a brief discussion of formal systems and logic in general, Dustin will dive in to the lambda calculus and make enough constructions to convince you that it really is capable of expressing anything that is "computable". Dustin then talks about the simply typed lambda calculus and the Curry-Howard-Lambek correspondence, which asserts that programs and mathematical proofs are "the same thing".
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.
Minder jaar voor firma van Marcel VanthiltThierry Debels
De vennootschap van Marcel Vanthilt heeft de jaarrekening over 2015 neergelegd.
Het jaar 2015 was een minder goed jaar met een verlies van ruim 28.000 euro. In 2014 was er nog een winst van bijna 25.000 euro.
Портрет аудитории (соц-дем характеристики) самых популярный сайтов РМ. Сентябрь 2016
Profilul socio-demografic al audientei site-urilor din RM. Septembrie 2016
Disampaikan pada Rapat Koordinasi Wilayah IV
Asosiasi Pemerintah Kota Seluruh Indonesia (APEKSI) ke-12
DENPASAR, 2 Juni 2016
Dr. Tri Widodo W. Utomo, MA
Deputi Inovasi Administrasi Negara/
Plt. Deputi Kajian Kebijakan LAN-RI
http://inovasi.lan.go.id
Understanding The Bible Part Five Psalms, Isaiah, Tobit, Judith, and EstherEdward Hahnenberg
Part Five presents the classification of Psalms as well as the possible borrowing of textual material from the Ugaritic culture. The Book of Isaiah is discussed as three separate texts with three different authors. Also discussed are the Books of Tobit, Judith, and Esther.
Presented at DevWeek (24th March 2015)
Although not yet fully mainstream, functional programming has finally reached a critical mass of awareness among developers. The problem, however, is that many developers are up against an even greater critical mass of existing code. Much of this code purports to be object oriented, but beyond the use of the class keyword, falls somewhat short of putting the OO to good use.
Many techniques identified as functional have broader applicability. This session will explore how some FP habits can be incorporated into OOP practice.
This is a friendly Lambda Calculus Introduction by Dustin Mulcahey. LISP has its syntactic roots in a formal system called the lambda calculus. After a brief discussion of formal systems and logic in general, Dustin will dive in to the lambda calculus and make enough constructions to convince you that it really is capable of expressing anything that is "computable". Dustin then talks about the simply typed lambda calculus and the Curry-Howard-Lambek correspondence, which asserts that programs and mathematical proofs are "the same thing".
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 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 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 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 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.
Keynote presented at European Testing Conference (9th February 2017)
What happens when things break? What happens when software fails? We regard it as a normal and personal inconvenience when apps crash or servers become unavailable, but what are the implications beyond the individual user? Is software reliability simply a business decision or does it have economic, social and cultural consequences? What are the moral and practical implications for software developers? And when we talk of ‘systems’, are we part of the ‘system’? What about the bugs on our side of the keyboard? In this talk we will explore examples of failures in software and its application, and how they affect us at different scales, from user to society.
Seven Ineffective Coding Habits of Many ProgrammersKevlin Henney
Presented at DevTernity (1st December 2016)
Video available at https://www.youtube.com/watch?v=SUIUZ09mnwM
Habits help you manage the complexity of code. You apply existing skill and knowledge automatically to the detail while focusing on the bigger picture. But because you acquire habits largely by imitation, and rarely question them, how do you know your habits are effective? Many of the habits that programmers have for naming, formatting, commenting and unit testing do not stand up as rational and practical on closer inspection. This talk examines seven coding habits that are not as effective as programmers believe, and suggests alternatives.
Prosigns: Transforming Business with Tailored Technology SolutionsProsigns
Unlocking Business Potential: Tailored Technology Solutions by Prosigns
Discover how Prosigns, a leading technology solutions provider, partners with businesses to drive innovation and success. Our presentation showcases our comprehensive range of services, including custom software development, web and mobile app development, AI & ML solutions, blockchain integration, DevOps services, and Microsoft Dynamics 365 support.
Custom Software Development: Prosigns specializes in creating bespoke software solutions that cater to your unique business needs. Our team of experts works closely with you to understand your requirements and deliver tailor-made software that enhances efficiency and drives growth.
Web and Mobile App Development: From responsive websites to intuitive mobile applications, Prosigns develops cutting-edge solutions that engage users and deliver seamless experiences across devices.
AI & ML Solutions: Harnessing the power of Artificial Intelligence and Machine Learning, Prosigns provides smart solutions that automate processes, provide valuable insights, and drive informed decision-making.
Blockchain Integration: Prosigns offers comprehensive blockchain solutions, including development, integration, and consulting services, enabling businesses to leverage blockchain technology for enhanced security, transparency, and efficiency.
DevOps Services: Prosigns' DevOps services streamline development and operations processes, ensuring faster and more reliable software delivery through automation and continuous integration.
Microsoft Dynamics 365 Support: Prosigns provides comprehensive support and maintenance services for Microsoft Dynamics 365, ensuring your system is always up-to-date, secure, and running smoothly.
Learn how our collaborative approach and dedication to excellence help businesses achieve their goals and stay ahead in today's digital landscape. From concept to deployment, Prosigns is your trusted partner for transforming ideas into reality and unlocking the full potential of your business.
Join us on a journey of innovation and growth. Let's partner for success with Prosigns.
Unleash Unlimited Potential with One-Time Purchase
BoxLang is more than just a language; it's a community. By choosing a Visionary License, you're not just investing in your success, you're actively contributing to the ongoing development and support of BoxLang.
Enhancing Research Orchestration Capabilities at ORNL.pdfGlobus
Cross-facility research orchestration comes with ever-changing constraints regarding the availability and suitability of various compute and data resources. In short, a flexible data and processing fabric is needed to enable the dynamic redirection of data and compute tasks throughout the lifecycle of an experiment. In this talk, we illustrate how we easily leveraged Globus services to instrument the ACE research testbed at the Oak Ridge Leadership Computing Facility with flexible data and task orchestration capabilities.
Globus Connect Server Deep Dive - GlobusWorld 2024Globus
We explore the Globus Connect Server (GCS) architecture and experiment with advanced configuration options and use cases. This content is targeted at system administrators who are familiar with GCS and currently operate—or are planning to operate—broader deployments at their institution.
Paketo Buildpacks : la meilleure façon de construire des images OCI? DevopsDa...Anthony Dahanne
Les Buildpacks existent depuis plus de 10 ans ! D’abord, ils étaient utilisés pour détecter et construire une application avant de la déployer sur certains PaaS. Ensuite, nous avons pu créer des images Docker (OCI) avec leur dernière génération, les Cloud Native Buildpacks (CNCF en incubation). Sont-ils une bonne alternative au Dockerfile ? Que sont les buildpacks Paketo ? Quelles communautés les soutiennent et comment ?
Venez le découvrir lors de cette session ignite
Code reviews are vital for ensuring good code quality. They serve as one of our last lines of defense against bugs and subpar code reaching production.
Yet, they often turn into annoying tasks riddled with frustration, hostility, unclear feedback and lack of standards. How can we improve this crucial process?
In this session we will cover:
- The Art of Effective Code Reviews
- Streamlining the Review Process
- Elevating Reviews with Automated Tools
By the end of this presentation, you'll have the knowledge on how to organize and improve your code review proces
How Does XfilesPro Ensure Security While Sharing Documents in Salesforce?XfilesPro
Worried about document security while sharing them in Salesforce? Fret no more! Here are the top-notch security standards XfilesPro upholds to ensure strong security for your Salesforce documents while sharing with internal or external people.
To learn more, read the blog: https://www.xfilespro.com/how-does-xfilespro-make-document-sharing-secure-and-seamless-in-salesforce/
Into the Box Keynote Day 2: Unveiling amazing updates and announcements for modern CFML developers! Get ready for exciting releases and updates on Ortus tools and products. Stay tuned for cutting-edge innovations designed to boost your productivity.
Globus Compute wth IRI Workflows - GlobusWorld 2024Globus
As part of the DOE Integrated Research Infrastructure (IRI) program, NERSC at Lawrence Berkeley National Lab and ALCF at Argonne National Lab are working closely with General Atomics on accelerating the computing requirements of the DIII-D experiment. As part of the work the team is investigating ways to speedup the time to solution for many different parts of the DIII-D workflow including how they run jobs on HPC systems. One of these routes is looking at Globus Compute as a way to replace the current method for managing tasks and we describe a brief proof of concept showing how Globus Compute could help to schedule jobs and be a tool to connect compute at different facilities.
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.
Large Language Models and the End of ProgrammingMatt Welsh
Talk by Matt Welsh at Craft Conference 2024 on the impact that Large Language Models will have on the future of software development. In this talk, I discuss the ways in which LLMs will impact the software industry, from replacing human software developers with AI, to replacing conventional software with models that perform reasoning, computation, and problem-solving.
Strategies for Successful Data Migration Tools.pptxvarshanayak241
Data migration is a complex but essential task for organizations aiming to modernize their IT infrastructure and leverage new technologies. By understanding common challenges and implementing these strategies, businesses can achieve a successful migration with minimal disruption. Data Migration Tool like Ask On Data play a pivotal role in this journey, offering features that streamline the process, ensure data integrity, and maintain security. With the right approach and tools, organizations can turn the challenge of data migration into an opportunity for growth and innovation.
Listen to the keynote address and hear about the latest developments from Rachana Ananthakrishnan and Ian Foster who review the updates to the Globus Platform and Service, and the relevance of Globus to the scientific community as an automation platform to accelerate scientific discovery.
Modern design is crucial in today's digital environment, and this is especially true for SharePoint intranets. The design of these digital hubs is critical to user engagement and productivity enhancement. They are the cornerstone of internal collaboration and interaction within enterprises.
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/
Innovating Inference - Remote Triggering of Large Language Models on HPC Clus...Globus
Large Language Models (LLMs) are currently the center of attention in the tech world, particularly for their potential to advance research. In this presentation, we'll explore a straightforward and effective method for quickly initiating inference runs on supercomputers using the vLLM tool with Globus Compute, specifically on the Polaris system at ALCF. We'll begin by briefly discussing the popularity and applications of LLMs in various fields. Following this, we will introduce the vLLM tool, and explain how it integrates with Globus Compute to efficiently manage LLM operations on Polaris. Attendees will learn the practical aspects of setting up and remotely triggering LLMs from local machines, focusing on ease of use and efficiency. This talk is ideal for researchers and practitioners looking to leverage the power of LLMs in their work, offering a clear guide to harnessing supercomputing resources for quick and effective LLM inference.
6. Time is like a river,
but frozen not flowing.
Eddies, pools and falls
are fixed in place,
timeless and immutable.
Kevlin Henney
"Remembrance of Things Past"
http://www.spec-fiction.ca/remembrance-of-things-past/
7. When it is not
necessary to
change, it is
necessary not to
change.
Lucius Cary
10. A type hierarchy is composed of subtypes and
supertypes. The intuitive idea of a subtype is one
whose objects provide all the behavior of objects
of another type (the supertype) plus something
extra. What is wanted here is something like the
following substitution property: If for each
object o1 of type S there is an object o2 of type T
such that for all programs P defined in terms of T,
the behavior of P is unchanged when o1 is
substituted for o2, then S is a subtype of T.
Barbara Liskov
"Data Abstraction and Hierarchy"
11. A type hierarchy is composed of subtypes and
supertypes. The intuitive idea of a subtype is one
whose objects provide all the behavior of objects
of another type (the supertype) plus something
extra. What is wanted here is something like the
following substitution property: If for each
object o1 of type S there is an object o2 of type T
such that for all programs P defined in terms of T,
the behavior of P is unchanged when o1 is
substituted for o2, then S is a subtype of T.
Barbara Liskov
"Data Abstraction and Hierarchy"
12. A type hierarchy is composed of subtypes and
supertypes. The intuitive idea of a subtype is one
whose objects provide all the behavior of objects
of another type (the supertype) plus something
extra. What is wanted here is something like the
following substitution property: If for each
object o1 of type S there is an object o2 of type T
such that for all programs P defined in terms of T,
the behavior of P is unchanged when o1 is
substituted for o2, then S is a subtype of T.
Barbara Liskov
"Data Abstraction and Hierarchy"
13. public class Ellipse
{
private double semiMajor, semiMinor;
public Ellipse(double a, double b) ...
public double semiMajorAxis() ...
public double semiMinorAxis() ...
public void semiMajorAxis(double a) ...
public void semiMinorAxis(double b) ...
...
}
public class Circle extends Ellipse
{
public Circle(double r) ...
public double radius() ...
public void radius(double r) ...
...
}
14. public class Ellipse
{
...
public void semiMajorAxis(double a) ...
public void semiMinorAxis(double b) ...
...
}
public class Circle extends Ellipse
{
...
@Override
public void semiMajorAxis(double a)
{
throw new UnsupportedOperationException();
}
@Override
public void semiMinorAxis(double b) ...
...
}
15. The reason a solution is so hard to come by is because the
problem is poorly stated: mathematics tells us that a circle is an
ellipse, so I can substitute a circle wherever an ellipse is required,
suggesting that a circle is a subtype of an ellipse.
Kevlin Henney
"Vicious Circles", Overload 8, June 1995
16. The reason a solution is so hard to come by is because the
problem is poorly stated: mathematics tells us that a circle is an
ellipse, so I can substitute a circle wherever an ellipse is required,
suggesting that a circle is a subtype of an ellipse.
The troubles start when we introduce any state modifying
functions, such as assignment or the ability to change the major
and minor axes independently.
Kevlin Henney
"Vicious Circles", Overload 8, June 1995
17. The reason a solution is so hard to come by is because the
problem is poorly stated: mathematics tells us that a circle is an
ellipse, so I can substitute a circle wherever an ellipse is required,
suggesting that a circle is a subtype of an ellipse.
The troubles start when we introduce any state modifying
functions, such as assignment or the ability to change the major
and minor axes independently.
We are so confident that we understand the mathematical
concepts behind circles and ellipses that we have not bothered to
ask any more questions of that domain.
Kevlin Henney
"Vicious Circles", Overload 8, June 1995
18. The first observation is that there is no way to change circles and
ellipses once you have created them.
Kevlin Henney
"Vicious Circles", Overload 8, June 1995
19. The first observation is that there is no way to change circles and
ellipses once you have created them.
This is the correct mathematical model: there are no side effects
in maths, conic sections do not undergo state changes, and there
are no variables in the programming sense of the word.
Kevlin Henney
"Vicious Circles", Overload 8, June 1995
20. The first observation is that there is no way to change circles and
ellipses once you have created them.
This is the correct mathematical model: there are no side effects
in maths, conic sections do not undergo state changes, and there
are no variables in the programming sense of the word.
Readers who are comfortable and familiar with functional
programming and data flow models will recognise the approach.
Kevlin Henney
"Vicious Circles", Overload 8, June 1995
21. The first observation is that there is no way to change circles and
ellipses once you have created them.
This is the correct mathematical model: there are no side effects
in maths, conic sections do not undergo state changes, and there
are no variables in the programming sense of the word.
Readers who are comfortable and familiar with functional
programming and data flow models will recognise the approach.
In the case of circles and ellipses, the circle is simply an ellipse
with specialised invariants. There is no additional state and none
of the members of an ellipse need overriding as they apply
equally well to a circle.
Kevlin Henney
"Vicious Circles", Overload 8, June 1995
22. public class Ellipse
{
private double semiMajor, semiMinor;
public Ellipse(double a, double b) ...
public double semiMajorAxis() ...
public double semiMinorAxis() ...
...
}
public class Circle extends Ellipse
{
public Circle(double r) ...
public double radius() ...
...
}
23. «interface»
UsageInterface
CommonCode
ConcreteLeaf ConcreteLeaf
Pure Interface Layer
Interfaces may extend
interfaces, but there is no
implementation defined in
this layer.
Common Code Layer
Only abstract classes are
defined in this layer, possibly
with inheritance, factoring out
any common implementation.
Concrete Class Layer
Only concrete classes are
defined, and they do not
inherit from one another.
ConcreteLeaf
24. public interface Ellipse
{
double semiMajorAxis();
double semiMinorAxis();
...
}
public interface Circle extends Ellipse
{
double radius();
...
}
25. public class ??? implements Ellipse
{
private double semiMajorAxis, semiMinorAxis;
...
}
public class ??? implements Circle
{
private double radius;
...
}
26. public class ??? implements Ellipse
{
private double semiMajorAxis, semiMinorAxis;
...
}
public class ??? implements Circle
{
private double radius;
...
}
The Naming of Cats is a difficult matter,
It isn't just one of your holiday games;
You may think at first I'm as mad as a hatter
When I tell you, a cat must have THREE DIFFERENT NAMES.
[...]
But above and beyond there's still one name left over,
And that is the name that you never will guess;
The name that no human research can discover—
But THE CAT HIMSELF KNOWS, and will never confess.
[...]
T S Eliot
27. public class Ellipse
{
private double semiMajor, semiMinor;
public Ellipse(double a, double b) ...
public double semiMajorAxis() ...
public double semiMinorAxis() ...
...
}
public class Circle
{
private double radius;
public Circle(double r) ...
public double radius() ...
public Ellipse toEllipse() ...
...
}
28. public class Ellipse
{
private double semiMajor, semiMinor;
public Ellipse(double a, double b) ...
public double semiMajorAxis() ...
public double semiMinorAxis() ...
public boolean isCircle() ...
...
}
30. Phenomenon: An element of what we can observe
in the world. Phenomena may be individuals or
relations. Individuals are entities, events, or
values. Relations are roles, states, or truths.
Individual: An individual is a phenomenon that
can be named and is distinct from every other
individual: for example, the number 17, George
III, or Deep Blue's first move against Kasparov.
Value: A value is an intangible individual that
exists outside time and space, and is not subject
to change.
31.
32.
33. Immutable Value
References to value objects are commonly distributed and
stored in fields. However, state changes to a value caused
by one object can have unexpected and unwanted side-
effects for any other object sharing the same value
instance. Copying the value can reduce the
synchronization overhead, but can also incur object
creation overhead.
Therefore:
Define a value object type whose instances are immutable.
The internal state of a value object is set at construction
and no subsequent modifications are allowed.
34. public class Date implements ...
{
...
public int getYear() ...
public int getMonth() ...
public int getDayInMonth() ...
public void setYear(int newYear) ...
public void setMonth(int newMonth) ...
public void setDayInMonth(int newDayInMonth) ...
...
}
35. public class Date implements ...
{
...
public int getYear() ...
public int getMonth() ...
public int getWeekInYear() ...
public int getDayInYear() ...
public int getDayInMonth() ...
public int getDayInWeek() ...
public void setYear(int newYear) ...
public void setMonth(int newMonth) ...
public void setWeekInYear(int newWeek) ...
public void setDayInYear(int newDayInYear) ...
public void setDayInMonth(int newDayInMonth) ...
public void setDayInWeek(int newDayInWeek) ...
...
}
36. public final class Date implements ...
{
...
public int getYear() ...
public int getMonth() ...
public int getWeekInYear() ...
public int getDayInYear() ...
public int getDayInMonth() ...
public int getDayInWeek() ...
...
}
37. public final class Date implements ...
{
...
public int year() ...
public int month() ...
public int weekInYear() ...
public int dayInYear() ...
public int dayInMonth() ...
public int dayInWeek() ...
...
}
38.
39.
40.
41.
42. Copied Value
Value objects are commonly distributed and stored in
fields. If value objects are shared between threads,
however, state changes caused by one object to a value
can have unexpected and unwanted side effects for any
other object sharing the same value instance. In a multi-
threaded environment shared state must be synchronized
between threads, but this introduces costly overhead for
frequent access.
Therefore:
Define a value object type whose instances are copyable.
When a value is used in communication with another
thread, ensure that the value is copied.
43. class date
{
public:
date(int year, int month, int day_in_month);
date(const date &);
date & operator=(const date &);
...
int year() const;
int month() const;
int day_in_month() const;
...
void year(int);
void month(int);
void day_in_month(int);
...
};
44. class date
{
public:
date(int year, int month, int day_in_month);
date(const date &);
date & operator=(const date &);
...
int year() const;
int month() const;
int day_in_month() const;
...
void set(int year, int month, int day_in_month);
...
};
today.set(2014, 4, 11);
45. class date
{
public:
date(int year, int month, int day_in_month);
date(const date &);
date & operator=(const date &);
...
int year() const;
int month() const;
int day_in_month() const;
...
};
today = date(2014, 4, 11);
46.
47. Referential transparency is a very
desirable property: it implies that
functions consistently yield the same
results given the same input,
irrespective of where and when they are
invoked. That is, function evaluation
depends less—ideally, not at all—on the
side effects of mutable state.
Edward Garson
"Apply Functional Programming Principles"
48. A book is simply the
container of an idea like
a bottle; what is inside
the book is what matters.
Angela Carter
53. In computing, a persistent data structure is a data structure
that always preserves the previous version of itself when it is
modified. Such data structures are effectively immutable, as
their operations do not (visibly) update the structure in-place,
but instead always yield a new updated structure.
http://en.wikipedia.org/wiki/Persistent_data_structure
(A persistent data structure is not a data structure committed
to persistent storage, such as a disk; this is a different and
unrelated sense of the word "persistent.")
56. I still have a deep fondness for the
Lisp model. It is simple, elegant, and
something with which all developers
should have an infatuation at least
once in their programming life.
Kevlin Henney
"A Fair Share (Part I)", CUJ C++ Experts Forum, October 2002
58. template<typename ValueType>
class list
{
public:
class iterator;
...
std::size_t size() const;
iterator begin() const;
iterator end() const;
const ValueType & front() const;
list popped_front() const;
list pushed_front() const;
void pop_front();
void push_front(const ValueType &);
...
private:
struct link
{
link(const ValueType & value, link * next);
ValueType value;
link * next;
};
link * head;
std::size_t length;
};
59. Hamlet: Yea, from the table of
my memory I'll wipe away all
trivial fond records.
William Shakespeare
The Tragedy of Hamlet
[Act I, Scene 5]
60. Garbage collection [...] is optional
in C++; that is, a garbage collector
is not a compulsory part of an
implementation.
Bjarne Stroustrup
http://stroustrup.com/C++11FAQ.html
62. public interface RecentlyUsedList
{
static final RecentlyUsedList nil = new Null();
boolean isEmpty();
int size();
String get(int index);
RecentlyUsedList add(String newItem);
RecentlyUsedList remove(String toRemove);
}
RecentlyUsedList list =
nil.add("Alice").add("Bob").add("Alice");
assert list.size() == 2;
assert list.get(0).equals("Alice");
assert list.get(1).equals("Bob");
63. Ophelia: 'Tis in my memory
locked, and you yourself shall
keep the key of it.
William Shakespeare
The Tragedy of Hamlet
[Act I, Scene 3]
64. A use-counted class is more
complicated than a non-use-
counted equivalent, and all of
this horsing around with use
counts takes a significant
amount of processing time.
Robert Murray
C++ Strategies and Tactics
72. paraskevidekatriaphobia, noun
The superstitious fear of Friday 13th.
Contrary to popular myth, this superstition is relatively recent
(19th century) and did not originate during or before the
medieval times.
Paraskevidekatriaphobia (or friggatriskaidekaphobia) also
reflects a particularly egocentric attributional bias: the universe
is prepared to rearrange causality and probability around the
believer based on an arbitrary and changeable calendar system,
in a way that is sensitive to geography, culture and time zone.
WordFriday.com
76. var friday13ths =
from day in Days.After(start)
where day.Day == 13
where day.DayOfWeek == DayOfWeek.Friday
select day;
foreach(var irrationalBelief in friday13ths)
{
...
}
77. public class Days : IEnumerable<DateTime>
{
public static Days After(DateTime startDay)
{
return new Days(startDay.AddDays(1));
}
public IEnumerator<DateTime> GetEnumerator()
{
for(var next = startDay;; next = next.AddDays(1))
yield return next;
}
...
private DateTime startDay;
}
78. Iterator
Clients often want to traverse elements that are
encapsulated within an aggregate, such as the
elements maintained by a collection. Clients may not
wish, however, to depend on the aggregate’s internal
structure to access components of interest.
Therefore:
Objectify the strategy to access and traverse the
components maintained by the aggregate into a
separate iterator component. Let this iterator be the
only means for clients to access the component.
79. Enumeration Method
Some types of aggregate [...] have representations that do
not conveniently support Iterator-based traversal.
Similarly, using an Iterator approach to access the
elements of an aggregate that is shared between threads
can incur unnecessary overhead from repeated locking.
Therefore:
Bring the iteration inside the aggregate and encapsulate
it in a single enumeration method that is responsible for
complete traversal. Pass the task of the loop—the action
to be executed on each element of the aggregate—as an
argument to the enumeration method, and apply it to
each element in turn.
80. Lifecycle Callback
The lifecycle of some objects is simple: their clients
create them before they are used, they stay alive as
long as they are used, and they are disposed of by
their clients when no longer used. However, some
objects have a much more complex lifecycle, driven by
the needs and events of their component environment.
Therefore:
Define key lifecycle events as callbacks in an interface
that is supported by framework objects. The
framework uses the callbacks to control the objects’
lifecycle explicitly.
82. Observer
Consumer objects sometimes depend on the state of, or
data maintained by, another provider object. If the
state of the provider object changes without notice,
however, the state of the dependent consumer objects
can become inconsistent.
Therefore:
Define a change-propagation mechanism in which the
provider—known as the ‘subject’—notifies registered
consumers—known as the ‘observers’—whenever its
state changes, so that the notified observers can
perform whatever actions they deem necessary.
83. void run(const function tests[], const char * label, listener & sink);
// precondition: tests is a non-null null-terminated array
// execution:
// sink.start_testing(label) ->
// (for each test in tests:
// (sink.before_test(...) ->
// (test executed ->
// (one of:
// (sink.test_passed(...) |
// sink.assertion_failed(...) |
// sink.exception_thrown(...)))
// sink.after_test(...))) ->
// sink.finish_testing(label)
SHUTL (Single-Header Unit Testing Lite), ACCU Conference 2007
84. void run(const function tests[], const char * label, listener & sink);
// precondition: tests is a non-null null-terminated array
// execution:
// sink.start_testing(label) ->
// (for each test in tests:
// (sink.before_test(...) ->
// (test executed ->
// (one of:
// (sink.test_passed(...) |
// sink.assertion_failed(...) |
// sink.exception_thrown(...)))
// sink.after_test(...))) ->
// sink.finish_testing(label)
SHUTL (Single-Header Unit Testing Lite), ACCU Conference 2007
90. Some people, when confronted with a
problem, think, "I know, I'll use threads,"
and then two they hav erpoblesms.
Ned Batchelder
https://twitter.com/#!/nedbat/status/194873829825327104
91. Shared memory is like a canvas where
threads collaborate in painting images,
except that they stand on the opposite
sides of the canvas and use guns rather
than brushes. The only way they can
avoid killing each other is if they shout
"duck!" before opening fire.
Bartosz Milewski
"Functional Data Structures and Concurrency in C++"
http://bartoszmilewski.com/2013/12/10/functional-data-structures-and-concurrency-in-c/
93. Instead of using threads and shared memory
as our programming model, we can use
processes and message passing. Process here
just means a protected independent state
with executing code, not necessarily an
operating system process.
Russel Winder
"Message Passing Leads to Better Scalability in Parallel Systems"
94. OOP to me means only messaging,
local retention and protection and
hiding of state-process, and
extreme late-binding of all things.
It can be done in Smalltalk and in
LISP. There are possibly other
systems in which this is possible,
but I'm not aware of them.
Alan Kay
95. Languages such as Erlang (and occam before
it) have shown that processes are a very
successful mechanism for programming
concurrent and parallel systems. Such
systems do not have all the synchronization
stresses that shared-memory, multithreaded
systems have.
Russel Winder
"Message Passing Leads to Better Scalability in Parallel Systems"
96.
97. Multithreading is just one
damn thing after, before, or
simultaneous with another.
Andrei Alexandrescu
99. Sender Receiver A
Message 1Message 3
Receiver B
In response to a message that it receives, an actor
can make local decisions, create more actors, send
more messages, and determine how to respond to
the next message received.
http://en.wikipedia.org/wiki/Actor_model
100. Concatenative programming is so called
because it uses function composition instead of
function application—a non-concatenative
language is thus called applicative.
Jon Purdy
http://evincarofautumn.blogspot.in/2012/02/
why-concatenative-programming-matters.html
106. This is the basic reason Unix pipes are so
powerful: they form a rudimentary string-based
concatenative programming language.
Jon Purdy
http://evincarofautumn.blogspot.in/2012/02/
why-concatenative-programming-matters.html
107.
108. Pipes and Filters
Some applications process streams of data: input data
streams are transformed stepwise into output data
streams. However, using common and familiar
request/response semantics for structuring such types
of application is typically impractical. Instead we must
specify an appropriate data flow model for them.
Therefore:
Divide the application's task into several self-contained
data processing steps and connect these steps to a
data processing pipeline via intermediate data buffers.