Complete Programming
•
0 likes•573 views
The document discusses the concept of complete programming which involves creating documentation, prototypes, code, and tests in a scientific approach and without duplication. It emphasizes writing documentation to plan stages and communicate ideas, creating functional prototypes to test use cases, writing dummy code in feature branches, and integrating tests to define problems, edge cases, and ensure quality. The full text can be found at the provided URL.
Report
Share
Report
Share
Download to read offline
Recommended
Continuous testing of a terminal font
A description of how and why my 3270 terminal font is tested and how other similar artifacts can be tested
The art of being an agile programmer
Programmers know good code. But in the context of today so competitive world of technology, this is not enough. We know this because good code has not saved us from doing overtime or getting bad performance reviews. What are we missing? We are forgetting about agile technical practices. In this presentation I am talking about how at MozaicWorks.com I have learned to use agile and XP technical practices for efficient quality product development.
Quick Intro to Clean Coding
This document provides an introduction to clean coding principles including identifying bad code through code smells, writing tests, and refactoring code. It outlines good practices for writing transparent, reasonable, and usable code and emphasizes writing tests as a safety belt and leaving the codebase in better condition. The document presents object-oriented design patterns, principles, knowledge of languages and libraries, code smells, testing, and code reviews/refactoring as tools for writing clean code. It links to an example of refactoring code in a step-by-step manner and emphasizes writing tests as the starting point and keeping them as the grammar for the system.
Five steps towards your testing dream
The document outlines five steps towards improving testing:
1. Use static code analysis tools to detect errors before runtime.
2. Gain more value from snapshot testing by snapshotting small components and using inline snapshots.
3. Build confidence in tests by writing tests that resemble user interactions and are implementation agnostic.
4. Create reliable end-to-end tests by running them in the same run loop as the app to improve debugging.
5. Focus testing efforts on what works best for the specific project and team.
More than Programming!
Eung Sophy is a software developer who has experience with many programming languages including Scala, Python, C, C++, Java, and more. They recommend learning object-oriented programming, design patterns, and good practices like version control, testing, and refactoring. The presentation provided demonstrations of design patterns, unit testing, and refactoring code to improve its structure without changing external behavior.
Beyond Unit Testing
This document discusses going beyond unit testing for web applications. It introduces several tools for testing different aspects of web applications, including Selenium IDE for browser-based testing, soapUI for web service testing, and JMeter for performance and load testing. These tools can be run from the command line as part of continuous integration with Jenkins. The document cites research that unit testing only detects an average of 25% of defects, while integration testing detects 45%, and code reviews have even higher effectiveness rates.
Importance of the quality of code
Good quality code is an essential property of a software because it could lead to financial losses or waste of time needed for further maintenance, modification or adjustments if code quality is not good enough.
Documenting Code - Patterns and Anti-patterns - NLPW 2016
How do we document code? A good solution is to create self-explanatory code; this somewhat eliminates the need to document the code. We still need some very basic documentation. Code comments are one form of documentation, that is often misused. This talk is about self-explanatory code, the documentation we need and code comment patterns and anti-patterns.
Recommended
Continuous testing of a terminal font
A description of how and why my 3270 terminal font is tested and how other similar artifacts can be tested
The art of being an agile programmer
Programmers know good code. But in the context of today so competitive world of technology, this is not enough. We know this because good code has not saved us from doing overtime or getting bad performance reviews. What are we missing? We are forgetting about agile technical practices. In this presentation I am talking about how at MozaicWorks.com I have learned to use agile and XP technical practices for efficient quality product development.
Quick Intro to Clean Coding
This document provides an introduction to clean coding principles including identifying bad code through code smells, writing tests, and refactoring code. It outlines good practices for writing transparent, reasonable, and usable code and emphasizes writing tests as a safety belt and leaving the codebase in better condition. The document presents object-oriented design patterns, principles, knowledge of languages and libraries, code smells, testing, and code reviews/refactoring as tools for writing clean code. It links to an example of refactoring code in a step-by-step manner and emphasizes writing tests as the starting point and keeping them as the grammar for the system.
Five steps towards your testing dream
The document outlines five steps towards improving testing:
1. Use static code analysis tools to detect errors before runtime.
2. Gain more value from snapshot testing by snapshotting small components and using inline snapshots.
3. Build confidence in tests by writing tests that resemble user interactions and are implementation agnostic.
4. Create reliable end-to-end tests by running them in the same run loop as the app to improve debugging.
5. Focus testing efforts on what works best for the specific project and team.
More than Programming!
Eung Sophy is a software developer who has experience with many programming languages including Scala, Python, C, C++, Java, and more. They recommend learning object-oriented programming, design patterns, and good practices like version control, testing, and refactoring. The presentation provided demonstrations of design patterns, unit testing, and refactoring code to improve its structure without changing external behavior.
Beyond Unit Testing
This document discusses going beyond unit testing for web applications. It introduces several tools for testing different aspects of web applications, including Selenium IDE for browser-based testing, soapUI for web service testing, and JMeter for performance and load testing. These tools can be run from the command line as part of continuous integration with Jenkins. The document cites research that unit testing only detects an average of 25% of defects, while integration testing detects 45%, and code reviews have even higher effectiveness rates.
Importance of the quality of code
Good quality code is an essential property of a software because it could lead to financial losses or waste of time needed for further maintenance, modification or adjustments if code quality is not good enough.
Documenting Code - Patterns and Anti-patterns - NLPW 2016
How do we document code? A good solution is to create self-explanatory code; this somewhat eliminates the need to document the code. We still need some very basic documentation. Code comments are one form of documentation, that is often misused. This talk is about self-explanatory code, the documentation we need and code comment patterns and anti-patterns.
Developers on test
Testing is important for project quality and reliability. Unit tests check individual code units for correct functionality, are fast and independent. Behavior-driven development (BDD) applies business needs through scenarios defined in Gherkin. Test doubles replace code to independently test objects like dummies, fakes, stubs and mocks. Integration tests check connections between components while acceptance tests check overall project behavior from the user perspective, ensuring expected functionality but are slower and require more maintenance.
Testing for people who hate testing
This document provides tips and tricks for organizing and writing simple tests with pytest. It recommends mimicking the application structure to make tests easy to remember and scope. Various fixtures are described that provide reusable test contexts and components, including request, user, and interaction fixtures. Case studies of testing mobile and web APIs at Livelovely are also mentioned.
Mocking in python
Daniel Davis is a software developer with 8 years of experience who now focuses on Python development and DevOps. He discusses his journey learning about unit testing and how mocking strategies can make testing easier. Mocking eliminates dependencies, allows testing of methods without return values, and helps test error handling. Various Python mocking libraries are presented. Examples show how to use mocking to test a matching algorithm in a dating app and to test a JSON reader class. The key benefits of mocking are that it simplifies unit tests by handling dependencies and verifying method behavior.
Idiomatic R for Rosetta Code (2013)
The document discusses Rosetta Code, an online collection of programming tasks solved in many different languages, and encourages attendees to contribute R solutions to unsolved tasks or improve existing solutions. It also reviews some existing R code on Rosetta Code to discuss idiomatic R style and seeks help with solving the task of finding Pythagorean triples with a given diameter in a functional way.
Testing Philosphies
The document discusses different testing philosophies for software, including unit testing, functional testing, integration testing, and acceptance testing. It also discusses philosophies of test-driven development, testing everything, unit independence, integration testing only, and a combination of unit and integration testing. The document provides definitions and examples of different testing approaches and encourages discussion on testing strategies.
Legacy code rehab.
The document discusses approaches to renovating legacy code, including risks of full rebuilds versus renovation. It promotes taking small, safe steps when renovating legacy code, such as scratch refactoring without keeping changes, telling the story of the system to understand it, writing sketches to explore changes, and using characterization tests to better understand the code. The workshop presentation provides a code sample and seeks feedback to further the discussion on safely evolving older codebases.
Documenting code yapceu2016
How do we document code? A good solution is to create self-explanatory code; this somewhat eliminates the need to document the code. We still need some very basic documentation. Code comments are one form of documentation, that is often misused. This talk is about self-explanatory code, the documentation we need and code comment patterns and anti-patterns.
Testing In Django
This document discusses the importance of testing in Django and provides examples of how to write tests. It describes how the Pinax project added tests after users were able to incorrectly edit ticket statuses. It recommends writing unit tests using the Django testing framework and provides a pattern for organizing and writing tests, including setting up test data and individual test methods. The document emphasizes that code without tests is "broken by design" and that writing tests improves code quality and avoids embarrassment.
Code review
Code review is the systematic examination of computer source code to find mistakes. It aims to improve overall software quality by identifying errors missed during initial development. Effective code review processes include pairing programmers, using tools to manage code review workflows, and establishing guidelines for what reviewers should evaluate like requirements, readability, performance, and error handling. Selecting the right code review tool is important to support the chosen workflow and meet a team's particular needs.
Design Patterns
Design patterns provide reusable solutions to common software design problems. When design patterns are not used, adding new features or fixing bugs takes more time due to increased technical debt. Design patterns fall into categories like creational, structural and behavioral. They promote principles like high cohesion and loose coupling. Tools like static analysis and UML can help analyze code for patterns. Applying patterns to legacy code requires adding tests first before refactoring. Different languages may emphasize different patterns based on their motivations.
ScalaItaly 2015 - Your Microservice as a Function
SoundCloud's microservice architecture is built mostly in Scala, using Finagle as its distributed systems workhorse. Finagle is an RPC system for the JVM, and it is based on a pipes-and-filters architecture that maps very nicely to functional programming concepts of higher-order functions and combinators. Over the past few years we have found that it is extremely useful to go even a step further and think of microservices as functions themselves. In this talk let's explore how SoundCloud uses Scala and Finagle, and how we started thinking of a microservices architecture as a special case of a functional system.
Technical debt management strategies
Raquel Pau discusses strategies for managing technical debt. She defines technical debt as code that is easy to implement in the short run but not the best overall solution. While some technical debt is inevitable when pursuing a minimum viable product strategy, it is important to measure all debt, control increases with quality gates and code reviews, and prioritize reducing existing debt through a "merciless" cleanup approach. Different types of technical debt include architectural, testing, code standards, infrastructure, and knowledge debt. Metrics, consequences, and solutions are proposed for managing each type of debt.
Code Quality Assurance v4 (2013)
The document summarizes a presentation by Peter Kofler on code quality assurance. It discusses Kofler's background and tools he uses to ensure code quality, including mindset/books, code kata exercises, test-driven development, code coverage, continuous integration, static analysis, and code review. It provides an example of using test-driven development to implement a prime factors kata coding exercise.
Designing Test Cases for the Gilded Rose Kata (2013)
This document outlines Peter Kofler's presentation on designing test cases for the Gilded Rose Kata. The presentation introduces Kofler and the coding dojo mindset of learning in a safe collaborative space. It describes the dojo structure and focuses on test-driven development skills like designing test cases. Attendees are instructed to get the Gilded Rose code from a GitHub repository, read the requirements, choose a testing framework, create tests to cover all cases, and experiment with different test styles.
Fast end-to-end-tests
This document summarizes Lars Thorup's presentation on fast end-to-end tests. It discusses the drawbacks of traditional end-to-end tests like being slow, imprecise, complicated and fragile. Unit tests are faster but rely on mocked dependencies. The presentation demonstrates a way to automatically generate mocks to test applications from end-to-end very quickly while avoiding the downsides of mocks. The demo shows a Node.js app with front-end and back-end tested at almost 100 end-to-end tests per second.
Testing 101: Three Rules for Testing at Ombu Labs
In this presentation we talk about three rules that we follow every week to deliver high quality code. We prefer to write tests in this order: Integration tests first, unit tests later.
We don't do TDD religiously but it is a good idea when you're facing a very complex problem.
Think about your code as a black box and think about all the possible inputs and outputs, all the possible paths that a user might take, all the possible ranges that the user may enter.
Don't test only the happy path, keep in mind the odd cases.
Is your code ready for testing?
Surely you've heard about Test-Driven Development, but do you use it? And do you like it? In this talk, we look at what TDD is, what the shortcomings of TDD are and what you could be doing instead.
Extreme Programming - to the next-level
This document discusses taking extreme programming principles to the next level by turning traditional practices "up to 11". It explores several ideas for achieving faster feedback including mob programming, continuous deployment, hypothesis-driven user stories, shared product ownership, monitoring-driven development, and continuous learning. The author asks the reader to consider which ideas may work to implement in their organization this month.
Alexandru Bolboaca - Unit Testing from the Trenches
This document provides clarification and practical ideas around unit testing. It begins by defining a unit test and the typical Arrange, Act, Assert structure. It then clarifies when tests are written, who writes different types of tests, and characteristics of good tests. Five practical ideas are presented to address common situations like bugs due to untested code, slow/unpredictable tests, and lack of test automation. The overall message is that unit tests form the "immune system" of a product and can replace manual testing and debugging when used properly.
Death to project documentation with eXtreme Programming
How to connect the agile principle "Working software over comprehensive documentation" with eXtreme Programming values of Honest communication and Rapid feedback and practices as TDD, Continuous integration, Whole team and Small releases.
We will analyze why blending those ideas and techniques together in the real world, remove any need of upfront documentation and increases quality, communication and confidence.
Perl 5 Quiz Chemnitz Edition
Extra brutales quiz, rund um Perl 5.16, Introspektion, und einige kaum beachtete Nischen von Perl 5
Writing Perl 6 Rx
Perl 6 is here today ... for some uses, like writing parsing scripts, that would be too complicated for a single Perl 5 regex. This is an overview what has changed.
More Related Content
What's hot
Developers on test
Testing is important for project quality and reliability. Unit tests check individual code units for correct functionality, are fast and independent. Behavior-driven development (BDD) applies business needs through scenarios defined in Gherkin. Test doubles replace code to independently test objects like dummies, fakes, stubs and mocks. Integration tests check connections between components while acceptance tests check overall project behavior from the user perspective, ensuring expected functionality but are slower and require more maintenance.
Testing for people who hate testing
This document provides tips and tricks for organizing and writing simple tests with pytest. It recommends mimicking the application structure to make tests easy to remember and scope. Various fixtures are described that provide reusable test contexts and components, including request, user, and interaction fixtures. Case studies of testing mobile and web APIs at Livelovely are also mentioned.
Mocking in python
Daniel Davis is a software developer with 8 years of experience who now focuses on Python development and DevOps. He discusses his journey learning about unit testing and how mocking strategies can make testing easier. Mocking eliminates dependencies, allows testing of methods without return values, and helps test error handling. Various Python mocking libraries are presented. Examples show how to use mocking to test a matching algorithm in a dating app and to test a JSON reader class. The key benefits of mocking are that it simplifies unit tests by handling dependencies and verifying method behavior.
Idiomatic R for Rosetta Code (2013)
The document discusses Rosetta Code, an online collection of programming tasks solved in many different languages, and encourages attendees to contribute R solutions to unsolved tasks or improve existing solutions. It also reviews some existing R code on Rosetta Code to discuss idiomatic R style and seeks help with solving the task of finding Pythagorean triples with a given diameter in a functional way.
Testing Philosphies
The document discusses different testing philosophies for software, including unit testing, functional testing, integration testing, and acceptance testing. It also discusses philosophies of test-driven development, testing everything, unit independence, integration testing only, and a combination of unit and integration testing. The document provides definitions and examples of different testing approaches and encourages discussion on testing strategies.
Legacy code rehab.
The document discusses approaches to renovating legacy code, including risks of full rebuilds versus renovation. It promotes taking small, safe steps when renovating legacy code, such as scratch refactoring without keeping changes, telling the story of the system to understand it, writing sketches to explore changes, and using characterization tests to better understand the code. The workshop presentation provides a code sample and seeks feedback to further the discussion on safely evolving older codebases.
Documenting code yapceu2016
How do we document code? A good solution is to create self-explanatory code; this somewhat eliminates the need to document the code. We still need some very basic documentation. Code comments are one form of documentation, that is often misused. This talk is about self-explanatory code, the documentation we need and code comment patterns and anti-patterns.
Testing In Django
This document discusses the importance of testing in Django and provides examples of how to write tests. It describes how the Pinax project added tests after users were able to incorrectly edit ticket statuses. It recommends writing unit tests using the Django testing framework and provides a pattern for organizing and writing tests, including setting up test data and individual test methods. The document emphasizes that code without tests is "broken by design" and that writing tests improves code quality and avoids embarrassment.
Code review
Code review is the systematic examination of computer source code to find mistakes. It aims to improve overall software quality by identifying errors missed during initial development. Effective code review processes include pairing programmers, using tools to manage code review workflows, and establishing guidelines for what reviewers should evaluate like requirements, readability, performance, and error handling. Selecting the right code review tool is important to support the chosen workflow and meet a team's particular needs.
Design Patterns
Design patterns provide reusable solutions to common software design problems. When design patterns are not used, adding new features or fixing bugs takes more time due to increased technical debt. Design patterns fall into categories like creational, structural and behavioral. They promote principles like high cohesion and loose coupling. Tools like static analysis and UML can help analyze code for patterns. Applying patterns to legacy code requires adding tests first before refactoring. Different languages may emphasize different patterns based on their motivations.
ScalaItaly 2015 - Your Microservice as a Function
SoundCloud's microservice architecture is built mostly in Scala, using Finagle as its distributed systems workhorse. Finagle is an RPC system for the JVM, and it is based on a pipes-and-filters architecture that maps very nicely to functional programming concepts of higher-order functions and combinators. Over the past few years we have found that it is extremely useful to go even a step further and think of microservices as functions themselves. In this talk let's explore how SoundCloud uses Scala and Finagle, and how we started thinking of a microservices architecture as a special case of a functional system.
Technical debt management strategies
Raquel Pau discusses strategies for managing technical debt. She defines technical debt as code that is easy to implement in the short run but not the best overall solution. While some technical debt is inevitable when pursuing a minimum viable product strategy, it is important to measure all debt, control increases with quality gates and code reviews, and prioritize reducing existing debt through a "merciless" cleanup approach. Different types of technical debt include architectural, testing, code standards, infrastructure, and knowledge debt. Metrics, consequences, and solutions are proposed for managing each type of debt.
Code Quality Assurance v4 (2013)
The document summarizes a presentation by Peter Kofler on code quality assurance. It discusses Kofler's background and tools he uses to ensure code quality, including mindset/books, code kata exercises, test-driven development, code coverage, continuous integration, static analysis, and code review. It provides an example of using test-driven development to implement a prime factors kata coding exercise.
Designing Test Cases for the Gilded Rose Kata (2013)
This document outlines Peter Kofler's presentation on designing test cases for the Gilded Rose Kata. The presentation introduces Kofler and the coding dojo mindset of learning in a safe collaborative space. It describes the dojo structure and focuses on test-driven development skills like designing test cases. Attendees are instructed to get the Gilded Rose code from a GitHub repository, read the requirements, choose a testing framework, create tests to cover all cases, and experiment with different test styles.
Fast end-to-end-tests
This document summarizes Lars Thorup's presentation on fast end-to-end tests. It discusses the drawbacks of traditional end-to-end tests like being slow, imprecise, complicated and fragile. Unit tests are faster but rely on mocked dependencies. The presentation demonstrates a way to automatically generate mocks to test applications from end-to-end very quickly while avoiding the downsides of mocks. The demo shows a Node.js app with front-end and back-end tested at almost 100 end-to-end tests per second.
Testing 101: Three Rules for Testing at Ombu Labs
In this presentation we talk about three rules that we follow every week to deliver high quality code. We prefer to write tests in this order: Integration tests first, unit tests later.
We don't do TDD religiously but it is a good idea when you're facing a very complex problem.
Think about your code as a black box and think about all the possible inputs and outputs, all the possible paths that a user might take, all the possible ranges that the user may enter.
Don't test only the happy path, keep in mind the odd cases.
Is your code ready for testing?
Surely you've heard about Test-Driven Development, but do you use it? And do you like it? In this talk, we look at what TDD is, what the shortcomings of TDD are and what you could be doing instead.
Extreme Programming - to the next-level
This document discusses taking extreme programming principles to the next level by turning traditional practices "up to 11". It explores several ideas for achieving faster feedback including mob programming, continuous deployment, hypothesis-driven user stories, shared product ownership, monitoring-driven development, and continuous learning. The author asks the reader to consider which ideas may work to implement in their organization this month.
Alexandru Bolboaca - Unit Testing from the Trenches
This document provides clarification and practical ideas around unit testing. It begins by defining a unit test and the typical Arrange, Act, Assert structure. It then clarifies when tests are written, who writes different types of tests, and characteristics of good tests. Five practical ideas are presented to address common situations like bugs due to untested code, slow/unpredictable tests, and lack of test automation. The overall message is that unit tests form the "immune system" of a product and can replace manual testing and debugging when used properly.
Death to project documentation with eXtreme Programming
How to connect the agile principle "Working software over comprehensive documentation" with eXtreme Programming values of Honest communication and Rapid feedback and practices as TDD, Continuous integration, Whole team and Small releases.
We will analyze why blending those ideas and techniques together in the real world, remove any need of upfront documentation and increases quality, communication and confidence.
What's hot (20)
Designing Test Cases for the Gilded Rose Kata (2013)
Designing Test Cases for the Gilded Rose Kata (2013)
Alexandru Bolboaca - Unit Testing from the Trenches
Alexandru Bolboaca - Unit Testing from the Trenches
Death to project documentation with eXtreme Programming
Death to project documentation with eXtreme Programming
Viewers also liked
Perl 5 Quiz Chemnitz Edition
Extra brutales quiz, rund um Perl 5.16, Introspektion, und einige kaum beachtete Nischen von Perl 5
Writing Perl 6 Rx
Perl 6 is here today ... for some uses, like writing parsing scripts, that would be too complicated for a single Perl 5 regex. This is an overview what has changed.
Modern wx perl
proposal for the GCL = Gui Composition Language to significantly simplify building surface of programs and maybe unifiy the API.
(Parameterized) Roles
Roles are an excellent object-oriented tool both for allomorphism and for
reuse.
Roles facilitate allomorphism by favoring "does this object do X" versus "is
this object a subclass of X". You often care more about capability than
inheritance. In a sense, roles encode types better than inheritance.
Roles also provide an excellent faculty for reuse. This effectively eliminates
multiple inheritance, which is often the only solution for sharing code between
unrelated classes.
Roles can combine with conflict detection. This eliminates accidental shadowing
of methods that is painful with multiple inheritance and mixins.
Parameterized roles (via MooseX::Role::Parameterized) improve the reusability
of roles by letting each consumer cater the role to its needs. This does
sacrifice some allomorphism, but there are ways to restore it.
Perl 5.20: Feature, Kultur, Module, Werkzeuge
der aktuelle Stand Perl 5.20 an features und Kultur: beeinflusst von Perl 6 wird an den wesentlichen Stellen aufgeräumt: dies war das Update für den Linuxtag in Chemnitz März 2015
P6 OO vs Moose (&Moo)
Part of a series of talk to help you write your first Perl 6 program today. So its basic syntax and concepts of its object orientation and a comparison to the widely used P5 OO system Moose which is similar by no accident.
Learning Perl 6
This document provides a summary of a tutorial on learning the Perl 6 programming language. It covers topics like scalars, variables, control structures, I/O, subroutines, regular expressions, modules, classes and objects. It suggests that in the 80 minute session, the presenters will be able to cover data, variables, control structures, I/O, subroutines and regular expressions, but may not have time for everything. It also provides information on getting started with Pugs and writing simple Perl 6 programs, as well as examples of core Perl 6 concepts like objects, methods, strings, arithmetic, conditionals and loops.
Viewers also liked (9)
Similar to Complete Programming
TDD Flow: The Mantra in Action
San Francisco Software Craftsmanship Meetup
Test Driven Developers Bay Area Meetup
TDD Flow: The Mantra in Action” is a talk + hands-on about the mantra of TDD and its core patterns. Here are some questions for this talk: What is TDD? How to write a good test that fails? How to write code enough to make the test pass? How to remove duplication? How to refactor code? How to create clean code? Is TDD about testing or design? How small should a test be? Should I only write unit tests? Should I estimate TDD? How to use TDD with other agile methods like Scrum, Kanban or BDD? And finally, how to flow in TDD?
BDD Testing Using Godog - Bangalore Golang Meetup # 32
BDD uses natural language to describe the "desired behaviour" of the system, that can be understood by both the developer and the customer
Demo of an existing BDD application using Godog predominantly used with golang
Angular Vienna - Use React tools for better Angular apps
Angular, React, Vue… they all have their own ecosystem, specific patterns and best practices… For us, the developers, this might become indeed very frustrating as we have to switch between various projects with various libraries… Have no fear, universal solution is here! In this session I will show you how to learn libraries/patterns/tooling only once and apply it everywhere.
Tech4goodPGH – Rapid Prototyping Workshop
The document discusses prototyping and introduces tools for prototyping mobile apps. It provides an overview of Jamaal Davis and his skills and hobbies. It then defines what a prototype is and explains the benefits of prototyping. Different types of prototypes like paper prototypes, click-through prototypes, and coded prototypes are presented. Common prototyping tools like Figma, InVision, Adobe XD, Framer Studio, and Proto.io are introduced along with their pros and cons. Finally, the document outlines a hands-on exercise to prototype a mobile app called "My Digital Persona" and provides resources for further prototyping learning.
Refactoring, 2nd Edition
This document discusses refactoring and summarizes the key points from Martin Fowler's book Refactoring. It covers what refactoring is, when it should be used by recognizing code smells, and how it should be done through small, incremental changes backed by thorough testing. The benefits of refactoring include improving code quality by reducing bugs and technical debt, while making the code easier to understand and modify. Tools now make refactoring easier by providing code analysis, refactoring suggestions, and quick fixes.
[drupalday2017] - Behat per Drupal: test automatici e molto di più
Behat è nato per semplificare il processo di accettazione da parte del cliente: per evitare ambiguità si realizza un test automatico (leggibile anche da chi non ha competenze tecniche) la cui esecuzione con successo garantisce che le specifiche siano rispettate. L'integrazione di Behat nel processo di sviluppo Drupal permette tuttavia di andare ben oltre: si può usare Behat per condividere le specifiche con il cliente, per guidare lo sviluppo (scrivendo il test prima del codice), per assistere il debug (usando uno scenario per popolare una situazione di errore ripetibile) e persino per migrare un sito da Drupal 7 a Drupal 8 (codificando il comportamento del sito in una serie di test che vengono poi usati come base per lo sviluppo del nuovo sito). Per tutti gli scenari descritti vedremo esempi basati sull'esperienza di Nuvole.
di Andrea Pescetti
New Ideas for Old Code - Greach
The document summarizes ideas for refactoring legacy code, including safely refactoring procedural code, better testing with Groovy, and managing dependencies. It also discusses social challenges like morale and politics, and provides suggestions for starting refactoring efforts and overcoming obstacles like lack of time or traction. Refactoring techniques presented include extracting methods, dependency injection, and using static methods to reduce dependencies.
Better Functional Design through TDD
The document discusses how test-driven development (TDD) can lead to better functional design. It explains that TDD focuses on defining requirements before implementation, limits test and code scope to reduce complexity, and makes dependencies explicit upfront. This helps produce code that is loosely coupled, simple to understand and maintain, and easy to test. The document recommends starting with examples or tests, keeping components small with single responsibilities, and designing dependent parts first.
Usable Software Design
How to improve software design by using UX mindset, techniques and practices, given that the user of software design is the developer.
Passing The Joel Test In The PHP World
The document discusses Joel Spolsky's "Joel Test" which evaluates software development teams. It applies the test's 12 questions to PHP teams and provides recommendations. Key points include using source control, continuous integration, bug tracking, specifications, estimating tasks, and providing developers with resources to do their jobs.
Managing Creativity
In this talk I talked about how,in the Kamaelia project, we manage the dilemma of encouraging innovation and creativity in a project whilst maintaining an engineered solution. Why? Because we find it allows a high level of creative freedom, whilst also providing a path through to a high level of confidence in the reliabilty of the final code.
Practices of agile developers
This document discusses practices of agile developers. It covers topics like version control, issue tracking, unit testing, pair programming, refactoring, code reviews, and collaboration tools. The overall message is on continuously improving expertise and productivity through techniques like feedback, testing, refactoring, and 10,000 hours of practice.
Computational practices for reproducible science
Reconciling bleeding-edge scientific results and reproducible research may seem a conundrum in our fast-paced high-pressure academic world. I discuss the practices that I found useful in computational work. At a high level, it is important to navigate the space between rapid experimentation and industrial-grade software development. I advocate adopting more and more software-engineering best practices as a project matures. I will also discuss how to turn the computational work into libraries, and to ensure the quality of the resulting libraries. And I conclude on how those libraries need to fit in the larger picture of the exercise of research to give better science.
Code generation
Code generation can be used to generate boilerplate code from models but requires manual coding to add behavior. Protected regions allow regenerating while preserving manual changes but not all tools support it. The "generation gap" pattern separates generated structure code from manual behavior code, but behavior is still written manually. Model-driven development with a general-purpose modeling language (GPL) like UML and full code generation from models could solve this by making models the central artifacts that are precise, complete and executable.
Alt Dot Net Usergroup: Does the world end if you stop using Visual Studio?
This document provides an introduction to using Vim as an alternative to Visual Studio for C# development. It discusses Vim's modes, basic editing commands, buffers, syntax highlighting, creating macros and functions, refactoring, spell checking, scriptability, navigating and interacting with code, building projects, source control integration, bookmarks, code completion, extensions, folding code, debugging, and next steps for enhancing it as an IDE for C#.
Tdd is not about testing (OOP)
TDD is now mainstream but a lot people don't know or don't remember what is its purpose. TDD is about software design not testing or catching bug. TDD helps developers to shape and create software with "good" design, what is a "good" design is something that we will discuss in the topic.
Deliberate Practice, New Learning Styles (2015)
Presentation about Deliberate Practice at the Austrian Testing Board "Expertentreff". This covers the Software Crisis, Developing Quality Software Developers and the mechanisms of Code Katas, Coding Dojos and Code Retreats.
Use React tools for better Angular apps
Angular, React, Vue… they all have their own ecosystem, specific patterns and best practices… For us, the developers, this might become indeed very frustrating as we have to switch between various projects with various libraries… Have no fear, universal solution is here! In this session I will show you how to learn libraries/patterns/tooling only once and apply it everywhere
Ian Cooper webinar for DDD Iran: Kent beck style tdd seven years after
Ian Cooper webinar for DDD Iran: Kent beck style tdd seven years afterIranian Domain-Driven Design Community
The original promise of TDD was that it would assist in guiding the development of clean code, but it often ends up polluting our architecture with excessive composition, is expensive to write, and becomes an obstacle to change, not an aid to refactoring. In this talk, we look at the fallacies of TDD and learn about the key principles that we should be following for mastery of this practice. This talk is intended for those who have been practicing TDD, or who have tried TDD and given up because of shortcomings in the approach they were taught.Rettig onprototyping
The document discusses the benefits of using low-fidelity or "lo-fi" prototyping, where interfaces are designed on paper and tested with real users early in the development process. This allows teams to go through many iterative design cycles in a short period of time to incorporate user feedback, as paper prototypes can be created and modified much faster than digital prototypes. The key benefits outlined are that lo-fi prototyping (1) is extremely fast, (2) brings user testing results very early in the process when changes are cheap to make, and (3) allows teams to try far more design ideas than with digital prototypes. The document provides guidance on assembling materials for building paper prototypes and preparing for useful user testing
Similar to Complete Programming (20)
BDD Testing Using Godog - Bangalore Golang Meetup # 32
BDD Testing Using Godog - Bangalore Golang Meetup # 32
Angular Vienna - Use React tools for better Angular apps
Angular Vienna - Use React tools for better Angular apps
[drupalday2017] - Behat per Drupal: test automatici e molto di più
[drupalday2017] - Behat per Drupal: test automatici e molto di più
Alt Dot Net Usergroup: Does the world end if you stop using Visual Studio?
Alt Dot Net Usergroup: Does the world end if you stop using Visual Studio?
Ian Cooper webinar for DDD Iran: Kent beck style tdd seven years after
Ian Cooper webinar for DDD Iran: Kent beck style tdd seven years after
More from lichtkind
Perl 6 in Context
There are a lot of operators in Perl 6, so many that it can be called an OOL: operator oriented language. Here I describe most of them from the angle of contexts, which Perl 6 has also much more than Perl 5.
Wx::Perl::Smart
The document describes the initialization of a graphical user interface (GUI) for a harmonicograph application using the Wx::Perl toolkit. It loads localization text, remembered favorites, and default parameter ranges. It then creates widgets like sliders, buttons and a drawing board and arranges them in a tabbed layout within a main frame window. The frame is populated with the widgets and initialized parameter values before being displayed.
Wundertüte Perl
Also du hast Ahnung von Perl 5.14, dann lass mal sehen wie du aus folgende fragen Antwortest?
Perl 6 Regex und Grammars
this talk should you prepare you for the new syntax, so you can write Perl 6 today
Perl 6 Datastructures
The document discusses Perl 6 data structures such as arrays and hashes. It provides examples of declaring and accessing array variables in Perl 5 and Perl 6. Some key points include: arrays can be initialized using parentheses or brackets in both Perl 5 and 6; the length or number of elements of an array can be obtained using the length or elems methods; individual elements can be accessed using array indexing syntax; and Perl 6 introduces additional syntactic sugar for working with arrays compared to Perl 5.
Perl 6 Datenstrukturen
Funktionsweisen der Perl 6 arrays and Hashes erklärt, mit Beispielen und einem lustigen Quiz
Document Driven Development
there are many reasons to write the docs even before the tests. in this talk i explained why.
- docs get ready when software is
- there are complete and up to date
- quality of program inceases
- when done properly it even adds much more dev time
Bettereditors
The document discusses various features that editors should have, including navigation by content (e.g. variables, strings, numbers, braces), selection methods (e.g. by word, line, block, string), and backup options (e.g. backup files, version control systems). It also covers input methods, the tooltree interface, and ways to work with content like templates and an assistant.
Hgit
This document compares features and syntax between the version control systems Mercurial (Hg) and Git. It covers initializing repositories, common terminology like working directories and changesets, viewing changes and revisions, branching and merging, configuration files, reverting changes, and version control integration libraries. The focus is on highlighting similarities and differences at a high level rather than advocating for one over the other.
Was können wir von Rebol lernen?
Rebol hat strikt überprüfte Datentypen und erlaubt einfache Definition einer eigenen DSL. Daher kennt es viele Kontexte und ist unglaublich ausdrucksstark. Rebolprogramme können so kurz werden, daß selbst Perl etwas davon lernen kann.
Perl Testing
The document discusses the history and evolution of testing in Perl from its early days in the 1980s to modern techniques. It covers key topics like the development of Test Anything Protocol (TAP), important testing modules like Test::More, Test::Simple, and tools for testing documentation, code quality, and more. Various commands for running tests are also presented.
Perl in der Wiki
german Talk about my various activities in Wikis and a style guide how to write and behave in wikis.
What is Kephra about?
some thought about what would a perfect editor look like and how we heading toward that with Kephra, ther perlish Editor written in Perl
What we can learn from Rebol?
Aout philosophy and features of Rebol and how get some of the interesting inside of Perl. Held at YAPC::EU 2010 in Pisa.
More from lichtkind (16)
Recently uploaded
Best 20 SEO Techniques To Improve Website Visibility In SERP
Boost your website's visibility with proven SEO techniques! Our latest blog dives into essential strategies to enhance your online presence, increase traffic, and rank higher on search engines. From keyword optimization to quality content creation, learn how to make your site stand out in the crowded digital landscape. Discover actionable tips and expert insights to elevate your SEO game.
National Security Agency - NSA mobile device best practices
Threats to mobile devices are more prevalent and increasing in scope and complexity. Users of mobile devices desire to take full advantage of the features
available on those devices, but many of the features provide convenience and capability but sacrifice security. This best practices guide outlines steps the users can take to better protect personal devices and information.
5th LF Energy Power Grid Model Meet-up Slides
5th Power Grid Model Meet-up
It is with great pleasure that we extend to you an invitation to the 5th Power Grid Model Meet-up, scheduled for 6th June 2024. This event will adopt a hybrid format, allowing participants to join us either through an online Mircosoft Teams session or in person at TU/e located at Den Dolech 2, Eindhoven, Netherlands. The meet-up will be hosted by Eindhoven University of Technology (TU/e), a research university specializing in engineering science & technology.
Power Grid Model
The global energy transition is placing new and unprecedented demands on Distribution System Operators (DSOs). Alongside upgrades to grid capacity, processes such as digitization, capacity optimization, and congestion management are becoming vital for delivering reliable services.
Power Grid Model is an open source project from Linux Foundation Energy and provides a calculation engine that is increasingly essential for DSOs. It offers a standards-based foundation enabling real-time power systems analysis, simulations of electrical power grids, and sophisticated what-if analysis. In addition, it enables in-depth studies and analysis of the electrical power grid’s behavior and performance. This comprehensive model incorporates essential factors such as power generation capacity, electrical losses, voltage levels, power flows, and system stability.
Power Grid Model is currently being applied in a wide variety of use cases, including grid planning, expansion, reliability, and congestion studies. It can also help in analyzing the impact of renewable energy integration, assessing the effects of disturbances or faults, and developing strategies for grid control and optimization.
What to expect
For the upcoming meetup we are organizing, we have an exciting lineup of activities planned:
-Insightful presentations covering two practical applications of the Power Grid Model.
-An update on the latest advancements in Power Grid -Model technology during the first and second quarters of 2024.
-An interactive brainstorming session to discuss and propose new feature requests.
-An opportunity to connect with fellow Power Grid Model enthusiasts and users.
Digital Marketing Trends in 2024 | Guide for Staying Ahead
https://www.wask.co/ebooks/digital-marketing-trends-in-2024
Feeling lost in the digital marketing whirlwind of 2024? Technology is changing, consumer habits are evolving, and staying ahead of the curve feels like a never-ending pursuit. This e-book is your compass. Dive into actionable insights to handle the complexities of modern marketing. From hyper-personalization to the power of user-generated content, learn how to build long-term relationships with your audience and unlock the secrets to success in the ever-shifting digital landscape.
Energy Efficient Video Encoding for Cloud and Edge Computing Instances
Energy Efficient Video Encoding for Cloud and Edge Computing Instances
Generating privacy-protected synthetic data using Secludy and Milvus
During this demo, the founders of Secludy will demonstrate how their system utilizes Milvus to store and manipulate embeddings for generating privacy-protected synthetic data. Their approach not only maintains the confidentiality of the original data but also enhances the utility and scalability of LLMs under privacy constraints. Attendees, including machine learning engineers, data scientists, and data managers, will witness first-hand how Secludy's integration with Milvus empowers organizations to harness the power of LLMs securely and efficiently.
Ocean lotus Threat actors project by John Sitima 2024 (1).pptx
Ocean Lotus cyber threat actors represent a sophisticated, persistent, and politically motivated group that poses a significant risk to organizations and individuals in the Southeast Asian region. Their continuous evolution and adaptability underscore the need for robust cybersecurity measures and international cooperation to identify and mitigate the threats posed by such advanced persistent threat groups.
OpenID AuthZEN Interop Read Out - Authorization
During Identiverse 2024 and EIC 2024, members of the OpenID AuthZEN WG got together and demoed their authorization endpoints conforming to the AuthZEN API
Taking AI to the Next Level in Manufacturing.pdf
Read Taking AI to the Next Level in Manufacturing to gain insights on AI adoption in the manufacturing industry, such as:
1. How quickly AI is being implemented in manufacturing.
2. Which barriers stand in the way of AI adoption.
3. How data quality and governance form the backbone of AI.
4. Organizational processes and structures that may inhibit effective AI adoption.
6. Ideas and approaches to help build your organization's AI strategy.
Monitoring and Managing Anomaly Detection on OpenShift.pdf
Monitoring and Managing Anomaly Detection on OpenShift
Overview
Dive into the world of anomaly detection on edge devices with our comprehensive hands-on tutorial. This SlideShare presentation will guide you through the entire process, from data collection and model training to edge deployment and real-time monitoring. Perfect for those looking to implement robust anomaly detection systems on resource-constrained IoT/edge devices.
Key Topics Covered
1. Introduction to Anomaly Detection
- Understand the fundamentals of anomaly detection and its importance in identifying unusual behavior or failures in systems.
2. Understanding Edge (IoT)
- Learn about edge computing and IoT, and how they enable real-time data processing and decision-making at the source.
3. What is ArgoCD?
- Discover ArgoCD, a declarative, GitOps continuous delivery tool for Kubernetes, and its role in deploying applications on edge devices.
4. Deployment Using ArgoCD for Edge Devices
- Step-by-step guide on deploying anomaly detection models on edge devices using ArgoCD.
5. Introduction to Apache Kafka and S3
- Explore Apache Kafka for real-time data streaming and Amazon S3 for scalable storage solutions.
6. Viewing Kafka Messages in the Data Lake
- Learn how to view and analyze Kafka messages stored in a data lake for better insights.
7. What is Prometheus?
- Get to know Prometheus, an open-source monitoring and alerting toolkit, and its application in monitoring edge devices.
8. Monitoring Application Metrics with Prometheus
- Detailed instructions on setting up Prometheus to monitor the performance and health of your anomaly detection system.
9. What is Camel K?
- Introduction to Camel K, a lightweight integration framework built on Apache Camel, designed for Kubernetes.
10. Configuring Camel K Integrations for Data Pipelines
- Learn how to configure Camel K for seamless data pipeline integrations in your anomaly detection workflow.
11. What is a Jupyter Notebook?
- Overview of Jupyter Notebooks, an open-source web application for creating and sharing documents with live code, equations, visualizations, and narrative text.
12. Jupyter Notebooks with Code Examples
- Hands-on examples and code snippets in Jupyter Notebooks to help you implement and test anomaly detection models.
Unlock the Future of Search with MongoDB Atlas_ Vector Search Unleashed.pdf
Discover how MongoDB Atlas and vector search technology can revolutionize your application's search capabilities. This comprehensive presentation covers:
* What is Vector Search?
* Importance and benefits of vector search
* Practical use cases across various industries
* Step-by-step implementation guide
* Live demos with code snippets
* Enhancing LLM capabilities with vector search
* Best practices and optimization strategies
Perfect for developers, AI enthusiasts, and tech leaders. Learn how to leverage MongoDB Atlas to deliver highly relevant, context-aware search results, transforming your data retrieval process. Stay ahead in tech innovation and maximize the potential of your applications.
#MongoDB #VectorSearch #AI #SemanticSearch #TechInnovation #DataScience #LLM #MachineLearning #SearchTechnology
Columbus Data & Analytics Wednesdays - June 2024
Columbus Data & Analytics Wednesdays, June 2024 with Maria Copot 20
20240609 QFM020 Irresponsible AI Reading List May 2024
Everything I found interesting about the irresponsible use of machine intelligence in May 2024
Webinar: Designing a schema for a Data Warehouse
Are you new to data warehouses (DWH)? Do you need to check whether your data warehouse follows the best practices for a good design? In both cases, this webinar is for you.
A data warehouse is a central relational database that contains all measurements about a business or an organisation. This data comes from a variety of heterogeneous data sources, which includes databases of any type that back the applications used by the company, data files exported by some applications, or APIs provided by internal or external services.
But designing a data warehouse correctly is a hard task, which requires gathering information about the business processes that need to be analysed in the first place. These processes must be translated into so-called star schemas, which means, denormalised databases where each table represents a dimension or facts.
We will discuss these topics:
- How to gather information about a business;
- Understanding dictionaries and how to identify business entities;
- Dimensions and facts;
- Setting a table granularity;
- Types of facts;
- Types of dimensions;
- Snowflakes and how to avoid them;
- Expanding existing dimensions and facts.
Building Production Ready Search Pipelines with Spark and Milvus
Spark is the widely used ETL tool for processing, indexing and ingesting data to serving stack for search. Milvus is the production-ready open-source vector database. In this talk we will show how to use Spark to process unstructured data to extract vector representations, and push the vectors to Milvus vector database for search serving.
20240607 QFM018 Elixir Reading List May 2024
Everything I found interesting about the Elixir programming ecosystem in May 2024
Artificial Intelligence for XMLDevelopment
In the rapidly evolving landscape of technologies, XML continues to play a vital role in structuring, storing, and transporting data across diverse systems. The recent advancements in artificial intelligence (AI) present new methodologies for enhancing XML development workflows, introducing efficiency, automation, and intelligent capabilities. This presentation will outline the scope and perspective of utilizing AI in XML development. The potential benefits and the possible pitfalls will be highlighted, providing a balanced view of the subject.
We will explore the capabilities of AI in understanding XML markup languages and autonomously creating structured XML content. Additionally, we will examine the capacity of AI to enrich plain text with appropriate XML markup. Practical examples and methodological guidelines will be provided to elucidate how AI can be effectively prompted to interpret and generate accurate XML markup.
Further emphasis will be placed on the role of AI in developing XSLT, or schemas such as XSD and Schematron. We will address the techniques and strategies adopted to create prompts for generating code, explaining code, or refactoring the code, and the results achieved.
The discussion will extend to how AI can be used to transform XML content. In particular, the focus will be on the use of AI XPath extension functions in XSLT, Schematron, Schematron Quick Fixes, or for XML content refactoring.
The presentation aims to deliver a comprehensive overview of AI usage in XML development, providing attendees with the necessary knowledge to make informed decisions. Whether you’re at the early stages of adopting AI or considering integrating it in advanced XML development, this presentation will cover all levels of expertise.
By highlighting the potential advantages and challenges of integrating AI with XML development tools and languages, the presentation seeks to inspire thoughtful conversation around the future of XML development. We’ll not only delve into the technical aspects of AI-powered XML development but also discuss practical implications and possible future directions.
Recently uploaded (20)
Best 20 SEO Techniques To Improve Website Visibility In SERP
Best 20 SEO Techniques To Improve Website Visibility In SERP
National Security Agency - NSA mobile device best practices
National Security Agency - NSA mobile device best practices
Deep Dive: AI-Powered Marketing to Get More Leads and Customers with HyperGro...
Deep Dive: AI-Powered Marketing to Get More Leads and Customers with HyperGro...
Digital Marketing Trends in 2024 | Guide for Staying Ahead
Digital Marketing Trends in 2024 | Guide for Staying Ahead
Energy Efficient Video Encoding for Cloud and Edge Computing Instances
Energy Efficient Video Encoding for Cloud and Edge Computing Instances
Generating privacy-protected synthetic data using Secludy and Milvus
Generating privacy-protected synthetic data using Secludy and Milvus
Ocean lotus Threat actors project by John Sitima 2024 (1).pptx
Ocean lotus Threat actors project by John Sitima 2024 (1).pptx
Monitoring and Managing Anomaly Detection on OpenShift.pdf
Monitoring and Managing Anomaly Detection on OpenShift.pdf
Unlock the Future of Search with MongoDB Atlas_ Vector Search Unleashed.pdf
Unlock the Future of Search with MongoDB Atlas_ Vector Search Unleashed.pdf
20240609 QFM020 Irresponsible AI Reading List May 2024
20240609 QFM020 Irresponsible AI Reading List May 2024
Building Production Ready Search Pipelines with Spark and Milvus
Building Production Ready Search Pipelines with Spark and Milvus
Complete Programming
- 3. меня зовут́
- 4. меня́ зовут
- 5. меня́ зовут
- 6. they call me
- 8. Doing, not Being behaviour can be changed
- 9. Not Like Him
- 11. The Dog Thing
- 12. Don't Be This Dog
- 13. Nor This Cat
- 15. Agile
- 16. Agile
- 17. XP = Hacking?
- 19. Complete Program: Docs, Codes, Tests, Configs, Artwork, Gui
- 20. Complete Repo: No Duplication All Metadocs
- 21. Also
- 22. I Write For:
- 26. Docs:
- 30. Prototypes:
- 33. Code:
- 34. Code: Dummy
- 37. Tests:
- 38. Tests: not helping well to define Problem