Carlos Ble presented on effective entrepreneurship for software developers in the mobile age. He discussed building the right software through lean startup principles and impact mapping. He also covered building software right through practices like clean code, SOLID principles, test-driven development, continuous delivery, and mobile testing. The presentation provided an interactive hands-on session and concluded that the most important things are to continuously improve, have good communication skills, and be a good teammate.
Imagine a team developing to a specific business domain. We use languages to communicate with the client, company and within the team. We also use programming languages to develop the software. And still, we want our code to express, no only a correct syntax for that language, but the knowledge of the business domain in which we are developing.
And if it was possible to capture the business meaning and transforme it into a language?
This talk is about DSLs, it's architecture, business use, and also how to implement and test them.
Dynamic Languages In The Enterprise (4developers march 2009)Ivo Jansch
Slightly more generic version of my 'Enterprise PHP' talk, adjusted for the 4developers conference's 'dedicated languages' track that features developers with different backgrounds.
This backend developer roadmap provides guidance for learning the necessary building blocks to become a modern backend developer, including learning basic front-end development with HTML, CSS, and JavaScript. It recommends choosing a programming language like Python, JavaScript, Java, Ruby, or PHP, and then selecting a framework that corresponds to the chosen language, such as Django, Flask, Laravel, or Express. It outlines key backend concepts, databases, caching, authentication methods, and deployment options one should learn to be a successful backend developer.
This document summarizes an Agile programming experience day in Ukraine. The goal is for attendees to have fun programming now and to think better by practicing their skills. The agenda includes a description of a minesweeper coding kata demonstration featuring pair programming. Attendees are encouraged to observe how the pair interacts, designs the code, and progresses through testing. The benefits of practices like test-driven development, pairing, and refactoring are discussed. The conclusion encourages practicing programming skills at work, with coding dojos, and by freeing the mind.
Software Craftsmanship and Agile Code GamesMike Clement
Join us to talk about what it means to be a software craftsman, how the Software Craftsmanship Manifesto (http://manifesto.softwarecraftsmanship.org/) provides a framework for us to improve.
A large part of being a software craftsman is practice. Using different "code games" we can have a full toolbelt of activities that will help us (and those around us) become better at our craft.
Agile software development promises the ability to deliver value quickly. But this isn’t just a matter of process. Uncle Bob says "the only way to go fast is to go well." But how do we go well? As software developers, we can only deliver features as fast as the code base and our skills allow us. Unfortunately the quality of our code base is directly related to our skill in the past.
Musicians and athletes spend most of their time practicing, not performing. As software developers (aspiring craftsmen) we must have practice sessions that allow us to improve our skills and develop better “code sense”. We’ll look at some different “agile code games” that will help us improve our craft.
Structured data:
- What is it?
- Data modelling standards
- Semantic Web
Knowledge Organisation Systems
- Natural language → controlled language
- Controlled vocabulary → ontology
- Design considerations & user impact
This document summarizes a workshop on Behavior-Driven Development (BDD) for Rich Internet Applications (RIAs) with JavaScript. It outlines the BDD process, which involves specifying user stories and acceptance criteria, writing scenarios to define desired behavior, and using an outside-in approach with test-driven development. It emphasizes writing unit tests with test doubles before integrating components. The workshop includes exercises for connecting a business API to a service with unit tests, connecting the UI to the service, implementing the service and interactor, and implementing a textbox widget with integration tests. It also discusses architecture patterns like passive view and reviewing non-functional requirements.
Imagine a team developing to a specific business domain. We use languages to communicate with the client, company and within the team. We also use programming languages to develop the software. And still, we want our code to express, no only a correct syntax for that language, but the knowledge of the business domain in which we are developing.
And if it was possible to capture the business meaning and transforme it into a language?
This talk is about DSLs, it's architecture, business use, and also how to implement and test them.
Dynamic Languages In The Enterprise (4developers march 2009)Ivo Jansch
Slightly more generic version of my 'Enterprise PHP' talk, adjusted for the 4developers conference's 'dedicated languages' track that features developers with different backgrounds.
This backend developer roadmap provides guidance for learning the necessary building blocks to become a modern backend developer, including learning basic front-end development with HTML, CSS, and JavaScript. It recommends choosing a programming language like Python, JavaScript, Java, Ruby, or PHP, and then selecting a framework that corresponds to the chosen language, such as Django, Flask, Laravel, or Express. It outlines key backend concepts, databases, caching, authentication methods, and deployment options one should learn to be a successful backend developer.
This document summarizes an Agile programming experience day in Ukraine. The goal is for attendees to have fun programming now and to think better by practicing their skills. The agenda includes a description of a minesweeper coding kata demonstration featuring pair programming. Attendees are encouraged to observe how the pair interacts, designs the code, and progresses through testing. The benefits of practices like test-driven development, pairing, and refactoring are discussed. The conclusion encourages practicing programming skills at work, with coding dojos, and by freeing the mind.
Software Craftsmanship and Agile Code GamesMike Clement
Join us to talk about what it means to be a software craftsman, how the Software Craftsmanship Manifesto (http://manifesto.softwarecraftsmanship.org/) provides a framework for us to improve.
A large part of being a software craftsman is practice. Using different "code games" we can have a full toolbelt of activities that will help us (and those around us) become better at our craft.
Agile software development promises the ability to deliver value quickly. But this isn’t just a matter of process. Uncle Bob says "the only way to go fast is to go well." But how do we go well? As software developers, we can only deliver features as fast as the code base and our skills allow us. Unfortunately the quality of our code base is directly related to our skill in the past.
Musicians and athletes spend most of their time practicing, not performing. As software developers (aspiring craftsmen) we must have practice sessions that allow us to improve our skills and develop better “code sense”. We’ll look at some different “agile code games” that will help us improve our craft.
Structured data:
- What is it?
- Data modelling standards
- Semantic Web
Knowledge Organisation Systems
- Natural language → controlled language
- Controlled vocabulary → ontology
- Design considerations & user impact
This document summarizes a workshop on Behavior-Driven Development (BDD) for Rich Internet Applications (RIAs) with JavaScript. It outlines the BDD process, which involves specifying user stories and acceptance criteria, writing scenarios to define desired behavior, and using an outside-in approach with test-driven development. It emphasizes writing unit tests with test doubles before integrating components. The workshop includes exercises for connecting a business API to a service with unit tests, connecting the UI to the service, implementing the service and interactor, and implementing a textbox widget with integration tests. It also discusses architecture patterns like passive view and reviewing non-functional requirements.
Writing Clean Code
The document discusses clean code, beginning with defining two types of programming - programming and good programming. It notes that clean code is code that can be understood and maintained by other developers besides the original author. The document then provides definitions of clean code from authors like Bjarne Stroustrup and "Big" Dave Thomas emphasizing readability, simplicity through single responsibility, and testability. An example of meaningful naming conventions is given, noting names are the most common problem for developers and are important for communicating intent. The document concludes that choosing good names takes time but makes code better and cleaner for all developers, including future self.
This document summarizes Rik Dryfoos' presentation on software craftsmanship. It discusses that craftsmanship focuses on not just delivering working software, but well-crafted software that is easy to maintain. It presents the costs of only focusing on delivery over ownership. Craftsmanship is defined as code that is simple, lacks duplication, and is readable. The document also discusses a manifesto for software craftsmanship and challenges that top-down management poses for craftsmanship.
This document summarizes Rik Dryfoos' presentation on software craftsmanship. It discusses that craftsmanship focuses on not just delivering working software, but well-crafted software that is easy to maintain. It presents the costs of only focusing on delivery over ownership. Craftsmanship is defined as code that is simple, lacks duplication, and is readable. The document also discusses a manifesto for software craftsmanship and challenges that top-down management poses for craftsmanship.
This document summarizes Harold Shinsato's presentation on crafting great code at the BigSkyDevCon conference. The presentation covers why it is important to craft code well, principles of mastery and modern agile development practices. It discusses techniques like test-driven development, refactoring, SOLID principles, design patterns, code katas, mob programming and the importance of building a collaborative culture and community.
What can we learn from other design disciplines? How do they learn design? What can we copy from them?
This is a challenge for software developers to start thinking as code designers, as people who use code as a material to prototype solutions to problems.
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.
This document provides guidance for high school and college students on learning to code. It discusses the benefits of coding skills, different types of coding careers, and what coding and software development entail. It then covers considerations for choosing a first programming language, including options for learning functional programming first or starting with Python. The document predicts that Rust will be in high demand in the coming years for developing embedded systems and web applications due to its safety and growing adoption. It recommends students learn foundational concepts in a beginner-friendly language before potentially specializing in Rust.
Java is an object-oriented programming language that is designed to be platform independent, simple, secure, robust, and highly scalable. It achieves platform independence by using bytecodes that are executed by the Java Virtual Machine, allowing Java programs to run on any device that supports Java without recompilation. Java has become one of the most popular programming languages due to its wide adoption across servers and desktops.
You're organised, you love spreadsheets, you're a great cheerleader, you handle a backlog with superhero skills, and now you're faced with managing a Drupal project and everything just feels foreign. It's not you, it's Drupal. The mix of site building, front end development, backend development, and over 20,000 contributed modules makes project management for Drupal exceptionally frustrating for people who've not worked with Drupal before.
This session will cover:
- the basic Drupal development workflow (from a developer's perspective, but without using developer jargon)
writing useful tickets which developers can accomplish
- estimation tips for multi-discipline tickets (design / back end / front end)
- ideal team structures -- and what to do if you can't get them
Updated from DrupalCamp London to include the truisms I've learned about being a first-time project manager.
OSDC 2015: Kris Buytaert | From ConfigManagementSucks to ConfigManagementLoveNETWAYS
Kris Buytaert discussed the evolution of infrastructure deployment and configuration management over the past 20 years. Early methods involved manual installations and copying config files (1996) while later approaches included tools like Mondo Rescue for single instances (2001), SystemImager for reproducible infrastructures (2003), and Kickstart/FAI for OS installation (2005). The talk advocates treating infrastructure as code using tools like Puppet, Chef, and CFEngine, with best practices like versioning, testing, and separate environments. It acknowledges early challenges in getting operators to adopt new methods but argues they are now essential for managing modern, distributed systems.
How to code in the XXI century without losing your headRené Olivo
This document discusses how to code effectively in the 21st century without being distracted by unnecessary noise. It identifies several types of noise that can prevent developers from delivering quality products, such as debates over programming languages and frameworks, premature optimization, editor preferences, and testing methodologies. The document recommends focusing on quality over optimization or new technologies, using the right tools for the job, implementing some testing, and agreeing on style guidelines to streamline collaboration. Overall, it encourages blocking out distracting debates and prioritizing effective development practices suited to the project.
15 Experts on the Art of JavaScript ProgrammingFusionCharts
This document summarizes tips from 15 JavaScript experts on best practices for learning and developing with JavaScript. Some key tips included learning from other languages and principles, producing code that solves problems, embracing interests outside programming, thoroughly learning basic concepts like objects and functions, understanding design patterns, and learning to debug and be a good collaborator early on. Later tips emphasized embracing functional programming concepts, knowing when to compromise versus stand firm, and having empathy for users.
The document discusses essential skills that programmers need versus accidental skills. Essential skills are hard to acquire but long-lasting, including things like managing complexity, writing readable code, and limiting bugs. These skills separate good programmers from bad. Accidental skills like knowledge of a specific programming language are easier to obtain but have shorter usefulness. The document advocates spending time on design, planning, unit testing, discussing solutions with others, and considering alternative solutions rather than just focusing on writing code. Developing essential skills through these practices can help programmers continuously learn and improve over the course of their careers.
(Image on page 3: it's the traditional fast/good/cheap trade-off. Something glitched in the conversion))
The decisions we make in getting software ready to ship can have lasting consequences for later versions. Early priorities can end up setting the direction for the whole project.
My presentation from PyConAU 2012 (including bonus slides that were cut before the talk due to time limitations)
The document discusses the Cathedral and Bazaar models of software development. The Cathedral model refers to closed, hierarchical development while the Bazaar model involves open, collaborative development. Some key points made include that every project starts by scratching a developer's personal itch, good programmers know what to rewrite, and that with enough reviewers all bugs can be shallow. The Bazaar style requires runnable code, ability to recognize designs, and an absence of power relationships. Motivations for open source include creative work rather than just money. Education is defined as learning what, when, and why to do things, while training is learning how.
Devops and Drupal focuses on the current state of devops practices among Drupal developers and system administrators. A survey of over 200 Drupal professionals found that while many are aware of devops concepts like continuous integration and deployment, few have fully implemented best practices for areas like automated testing, configuration management, and disaster recovery. Adopting a devops approach can help Drupal teams improve collaboration, deploy more frequently, and better manage systems over time.
The document discusses quality rails coding and provides tips for achieving high quality code. It recommends following the single responsibility principle by ensuring classes and methods each have a single well-defined responsibility. It also suggests using self-documenting code through clear naming and avoiding unnecessary documentation. Additionally, it advises having a well-thought out data model, conducting code reviews, and obsessively testing code to ensure a passing test suite. The overall goal is to write extensible, understandable code that is bug-free and easy to modify.
BDD for RIAs with JavaScript - Skills MatterCarlos Ble
This document discusses behavior-driven development (BDD) for rich internet applications (RIAs) using JavaScript. It explains that the business logic for BDD step definitions can live directly in the browser code. Outside-in test-driven development can start by testing the JavaScript application in the browser first before developing the server-side code, which would act as an adapter. The server-side features will emerge progressively as needed to support rules for security, data consistency, and a RESTful API. The document also covers testing JavaScript applications, event-oriented programming, promises, and references for further reading.
Writing Clean Code
The document discusses clean code, beginning with defining two types of programming - programming and good programming. It notes that clean code is code that can be understood and maintained by other developers besides the original author. The document then provides definitions of clean code from authors like Bjarne Stroustrup and "Big" Dave Thomas emphasizing readability, simplicity through single responsibility, and testability. An example of meaningful naming conventions is given, noting names are the most common problem for developers and are important for communicating intent. The document concludes that choosing good names takes time but makes code better and cleaner for all developers, including future self.
This document summarizes Rik Dryfoos' presentation on software craftsmanship. It discusses that craftsmanship focuses on not just delivering working software, but well-crafted software that is easy to maintain. It presents the costs of only focusing on delivery over ownership. Craftsmanship is defined as code that is simple, lacks duplication, and is readable. The document also discusses a manifesto for software craftsmanship and challenges that top-down management poses for craftsmanship.
This document summarizes Rik Dryfoos' presentation on software craftsmanship. It discusses that craftsmanship focuses on not just delivering working software, but well-crafted software that is easy to maintain. It presents the costs of only focusing on delivery over ownership. Craftsmanship is defined as code that is simple, lacks duplication, and is readable. The document also discusses a manifesto for software craftsmanship and challenges that top-down management poses for craftsmanship.
This document summarizes Harold Shinsato's presentation on crafting great code at the BigSkyDevCon conference. The presentation covers why it is important to craft code well, principles of mastery and modern agile development practices. It discusses techniques like test-driven development, refactoring, SOLID principles, design patterns, code katas, mob programming and the importance of building a collaborative culture and community.
What can we learn from other design disciplines? How do they learn design? What can we copy from them?
This is a challenge for software developers to start thinking as code designers, as people who use code as a material to prototype solutions to problems.
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.
This document provides guidance for high school and college students on learning to code. It discusses the benefits of coding skills, different types of coding careers, and what coding and software development entail. It then covers considerations for choosing a first programming language, including options for learning functional programming first or starting with Python. The document predicts that Rust will be in high demand in the coming years for developing embedded systems and web applications due to its safety and growing adoption. It recommends students learn foundational concepts in a beginner-friendly language before potentially specializing in Rust.
Java is an object-oriented programming language that is designed to be platform independent, simple, secure, robust, and highly scalable. It achieves platform independence by using bytecodes that are executed by the Java Virtual Machine, allowing Java programs to run on any device that supports Java without recompilation. Java has become one of the most popular programming languages due to its wide adoption across servers and desktops.
You're organised, you love spreadsheets, you're a great cheerleader, you handle a backlog with superhero skills, and now you're faced with managing a Drupal project and everything just feels foreign. It's not you, it's Drupal. The mix of site building, front end development, backend development, and over 20,000 contributed modules makes project management for Drupal exceptionally frustrating for people who've not worked with Drupal before.
This session will cover:
- the basic Drupal development workflow (from a developer's perspective, but without using developer jargon)
writing useful tickets which developers can accomplish
- estimation tips for multi-discipline tickets (design / back end / front end)
- ideal team structures -- and what to do if you can't get them
Updated from DrupalCamp London to include the truisms I've learned about being a first-time project manager.
OSDC 2015: Kris Buytaert | From ConfigManagementSucks to ConfigManagementLoveNETWAYS
Kris Buytaert discussed the evolution of infrastructure deployment and configuration management over the past 20 years. Early methods involved manual installations and copying config files (1996) while later approaches included tools like Mondo Rescue for single instances (2001), SystemImager for reproducible infrastructures (2003), and Kickstart/FAI for OS installation (2005). The talk advocates treating infrastructure as code using tools like Puppet, Chef, and CFEngine, with best practices like versioning, testing, and separate environments. It acknowledges early challenges in getting operators to adopt new methods but argues they are now essential for managing modern, distributed systems.
How to code in the XXI century without losing your headRené Olivo
This document discusses how to code effectively in the 21st century without being distracted by unnecessary noise. It identifies several types of noise that can prevent developers from delivering quality products, such as debates over programming languages and frameworks, premature optimization, editor preferences, and testing methodologies. The document recommends focusing on quality over optimization or new technologies, using the right tools for the job, implementing some testing, and agreeing on style guidelines to streamline collaboration. Overall, it encourages blocking out distracting debates and prioritizing effective development practices suited to the project.
15 Experts on the Art of JavaScript ProgrammingFusionCharts
This document summarizes tips from 15 JavaScript experts on best practices for learning and developing with JavaScript. Some key tips included learning from other languages and principles, producing code that solves problems, embracing interests outside programming, thoroughly learning basic concepts like objects and functions, understanding design patterns, and learning to debug and be a good collaborator early on. Later tips emphasized embracing functional programming concepts, knowing when to compromise versus stand firm, and having empathy for users.
The document discusses essential skills that programmers need versus accidental skills. Essential skills are hard to acquire but long-lasting, including things like managing complexity, writing readable code, and limiting bugs. These skills separate good programmers from bad. Accidental skills like knowledge of a specific programming language are easier to obtain but have shorter usefulness. The document advocates spending time on design, planning, unit testing, discussing solutions with others, and considering alternative solutions rather than just focusing on writing code. Developing essential skills through these practices can help programmers continuously learn and improve over the course of their careers.
(Image on page 3: it's the traditional fast/good/cheap trade-off. Something glitched in the conversion))
The decisions we make in getting software ready to ship can have lasting consequences for later versions. Early priorities can end up setting the direction for the whole project.
My presentation from PyConAU 2012 (including bonus slides that were cut before the talk due to time limitations)
The document discusses the Cathedral and Bazaar models of software development. The Cathedral model refers to closed, hierarchical development while the Bazaar model involves open, collaborative development. Some key points made include that every project starts by scratching a developer's personal itch, good programmers know what to rewrite, and that with enough reviewers all bugs can be shallow. The Bazaar style requires runnable code, ability to recognize designs, and an absence of power relationships. Motivations for open source include creative work rather than just money. Education is defined as learning what, when, and why to do things, while training is learning how.
Devops and Drupal focuses on the current state of devops practices among Drupal developers and system administrators. A survey of over 200 Drupal professionals found that while many are aware of devops concepts like continuous integration and deployment, few have fully implemented best practices for areas like automated testing, configuration management, and disaster recovery. Adopting a devops approach can help Drupal teams improve collaboration, deploy more frequently, and better manage systems over time.
The document discusses quality rails coding and provides tips for achieving high quality code. It recommends following the single responsibility principle by ensuring classes and methods each have a single well-defined responsibility. It also suggests using self-documenting code through clear naming and avoiding unnecessary documentation. Additionally, it advises having a well-thought out data model, conducting code reviews, and obsessively testing code to ensure a passing test suite. The overall goal is to write extensible, understandable code that is bug-free and easy to modify.
BDD for RIAs with JavaScript - Skills MatterCarlos Ble
This document discusses behavior-driven development (BDD) for rich internet applications (RIAs) using JavaScript. It explains that the business logic for BDD step definitions can live directly in the browser code. Outside-in test-driven development can start by testing the JavaScript application in the browser first before developing the server-side code, which would act as an adapter. The server-side features will emerge progressively as needed to support rules for security, data consistency, and a RESTful API. The document also covers testing JavaScript applications, event-oriented programming, promises, and references for further reading.
1. Effective entrepreneurship
for software developers
in the mobile age
Carlos Ble
carlosble.com - @carlosble
Presented at: Sociedad de Promoción Econónica de Gran Canaria (SPEGC).
Gran Canaria, 20 abril 2013
2. @carlosble
Building the right software
- Entrepreneurship
- Lean startup & Impact Mapping
- Agile, SbE & BDD
Building the software right
- Clean code & craftsmanship
- SOLID design & architecture
- TDD, and other XP practices
- Continuous delivery
- Native, HTML5+JavaScript, Xamarin...?
- Mobile testing
Interactive hands-on session :
- Code with me on the randori kata
5. @carlosble
Building the right software
●
Lean startup:
- Fail fast
- Validated learning - Market discovery
- Avoid waste
- Book: Lean startup by Eric Ries
●
SBE, BDD: What do we need and why?
It's all about communication... let's talk!
- Books & Authors:
- Gojko Adzic (3 books)
- The Cucumber Book (Matt & Aslak)
6. @carlosble
Building the right software
●
User stories:
Title (one line describing the story)
Narrative:
As a [role]
I want [feature]
So that [benefit]
Source: Dan North - http://dannorth.net/whats-in-a-story/
●
Personas (personajes in Spanish)
●
Impact mapping (impactmapping.org)
●
Planning & Analysis : Discover to Deliver [.com] (book)
7. @carlosble
Gherkin language: What, not how
Given Fred has bought a microwave
And the microwave costs 100€
When we refund the microwave
Then Fred should be refunded 100€
Source: Liz Keogh -
http://www.slideshare.net/lunivore/behavior-driven-development-11754474
8. @carlosble
Cucumber and step definitions
[Given(“Fred has bought a microwave”)]
public void GivenMicrowaveIsBought(){...}
[And(“the microwave costs (.*)€”)]
public void AndMicrowaveCosts(int cost){...}
[When(“we refund the microwave”)]
public void WhenWeRefundTheMicrowave(){...}
[Then(“Fred should be refunded (.*)€”)]
public void ThenShouldBeRefunded(int amount)
{
Assert...
}
Step definitions using C# with SpecFlow (Cucumber for .Net)
10. @carlosble
Building the software right
Software craftsmanship manifesto:
● Not only working software,
but also wellcrafted software
● Not only responding to change,
but also steadily adding value
● Not only individuals and interactions,
but also a community of professionals
● Not only customer collaboration,
but also productive partnerships
“The only way to go fast, is to go well” - Robert C. Martin
11. @carlosble
Building the software right
Clean Code:
Does it matter? - Cleancoders.com and the book
Low coupling, high cohesion, dependencies.
SOLID design principles:
Single Responsibility
Open/Closed
Liskov Substitution
Interface Segregation
Dependency Injection
TDD and Pair programming:
Minimalistic, goal driven, precise
12. @carlosble
Building the software right
OU?!
em,.. . DO Y
tr ol syst
ersion c on
v
ou h ave a
So y
14. @carlosble
eXtreme Programming
It's about VALUES:
●
Simplicity
●
Communication
●
Feedback
●
Courage → Honesty
- Book: Extreme Programming Explained: Embrace change
2nd edition, Kent Beck
15. @carlosble
The TDD Mantra
RED:
Before writing the code,
express your intent in
the form of a test Books:
> Test Driven –
Lasse Koskela
GREEN:
Don't think, just make > Growing object
the test pass oriented software
guided by tests –
with the minimun effort, Freeman & Pryce
the simplest way
> Diseño agil con
TDD –
REFACTOR: Carlos Ble & co.
Remove duplication
Improve naming
SOLID
16. @carlosble
Pair programming or... maximizing the amount
of work NOT done
●
The bottleneck of the project is not the keyboard.
●
Incredibly effective way of eliminating waste.
●
Best enemy of defects.
●
I always prefer to pair than coding alone (except on
those days when I don't feel any good).
●
Sinergy: 1+1 = 4
ODE
I TY C
UAL
HI GH Q
17. @carlosble
If you are in a team...
●
Code reviews.
●
Continuous integration.
●
Be a good team player: do your best always.
●
And before anything else... stick to the
principles and understand the values.
18. @carlosble
Architecture
Book: Code Complete, Steve McConnell
●
Major classes
●
Data Design
●
Business Rules
●
User Interface Design
●
Resource Management
●
Security
●
Performance
●
Scalability
●
Interoperability
●
Internationalization/Localization (i18n, l10n)
●
Input/Output
●
Error Processing
●
Fault Tolerance
●
Good architecture allows you to defer decisions
19. @carlosble
Design patterns
Book: Head first design patterns
What I use the most:
●
Factory
●
Template method
●
Wrapper
●
Observer
●
Mediator
●
Singleton
●
MVVM / MVP / Passive View
●
Let them emerge from your designs
20. @carlosble
Exploratory testing & UX
●
Even if you've got 100% test coverage, your app can
be broken (and it will).
●
Exploratory testing is always necessary.
●
Try to get the application tested by real testers.
●
Invite beta testers.
●
Don't forget about usability and User eXperience:
Books:
Don't make me think – Steve Krug
User interface design for programmers - Spolsky
21. @carlosble
Native or not native?
●
Some specialists are making good money
and native apps perform better than HTML+JS, but...
●
What do you need?
●
Powerful visual effects?
●
Targeting multiple platforms?
●
What are your skills? And your resources?
●
Are you productive with JavaScript?
●
Do you have to maintain it in the long run?
●
There are alternatives :
- PhoneGap + frameworks like jQuery mobile.
- Sencha Touch.
- Xamarin (C# development).
- Appcelerator.
- ...
22. @carlosble
Automated testing
in the mobile world
●
Calabash (multiplatform): http://calaba.sh (Cucumber friendly!)
- Demo: http://skillsmatter.com/podcast/java-jee/cross-platform-and-end-to-end-bdd-for-mobile
●
Frank (iOS): http://testingwithfrank.com/ (Cucumber friendly!)
●
Robolectric (Android): unit testing
But remember...
the mobile is just a delivery mechanism!
●
Book: Responsible design for Android - J.B. Rainsberger (leanpub)
23. @carlosble
Want to be a good developer?
●
Seek continuous improvement
- Read books (specially in English)
- Attend to conferences
- Listen to podcasts
- Share with the local communities
- Write a blog
- Work on some open source project
- Practice with code katas or pet projects
- Teach others
●
Improve your communications skills
●
Master your tools. Some examples:
- Can you type without looking at the keyboard?
- Do you know common shortcuts?
●
Be a good teammate
Book: Apprenticeship patterns – Hoover & Oshineye
24. @carlosble
Conclusions
●
It's not about money, just do your best as a
professional and work for a better world.
●
Don't worry to much about a particular technology,
learn about principles, patterns and techniques.
●
Although being a technology specialist might help you
make a lot of money in the short term.
●
Build the right software != Build the software right
●
Improve your communication skills because that is as
important as programming.
●
A great professional is always learning.
25. @carlosble
Related presentations
http://www.slideshare.net/carlosblejurado/best-practicesjsria
http://www.slideshare.net/carlosble/charla-tdd-uji-032010
http://www.slideshare.net/carlosblejurado/bdd-workshop-for-javascript-developers