Craftsmanship - professional tools for developers and architects

Code: Craft-practices-przybornik
Category: Craftsmanship
Format: 50% lecture / 50% workshop
Duration: 3 days
Target audience: developerzy
Enrollment: Groups, companies
Venue: Client's office.

The training is a synthesis of crucial elements of classic and modern software engineering.

It gives a general outlook on practical aspects of using discussed techniques in projects. Discussed issues are at the root of modern frameworks and technologies – which increases the level of their understanding and allows for a conscious use.

A professional in our approach:
  • perfectly uses development techniques and architectural styles,
  • can communicate with business using the DDD techniques,
  • selects the right tool for the class of a problem provides a high quality code

The training is intended for programmers and designers who want to expand their competences in terms of professional techniques that increase the quality of code and design. Obtained knowledge translates in a practical way to the productivity, measured in a wider perspective of time.

It's all about the content.

  • SOLID, GRASP and DDD techniques
  • Setting techniques in application and system architecture
  • All in the context of automatic testing
  • Real-life examples

Training Program

The content of our program can be customised during pre-training analysis.

  1. Object Oriented techniques
    1. Orienting the thinking in the OO style
    2. Code smell
    3. Traps of inheritance
      1. Closing the code for extension
      2. Replacing the inheritance with composition – practical benefits of changing approach
        1. Inheritance is not suitable for role modeling
        2. Liskov Substitution Principle
        3. Party pattern
        4. Role Object and Extension Object patterns
    4. GRASP - General Responsibility Assignment Software Patterns
    5. Practical use of SOLID
      1. Class cohesion
        1. How to achieve it
        2. How to detect code smell
      2. Openness for extension
        1. Strategy pattern
        2. 3 types of logic: stable, closure, selection of closures
      3. When inheritance has no use
      4. Range of interfaces
      5. Proper level of abstraction
      6. Striving for a code with readability close to the prose
        1. The subject.predicate(object, attribute) technique
      7. Invariant modeling technique
      8. Technique for determining class boundary based on the Use Case analysis
    6. Responsibility Driven Design
  2. Clean Code
    1. Detecting Code Smells
    2. Selected implementation and design Patterns
  3. Techniques for arranging the logic and application architecture patterns
    1. Division into the application and domain logic
    2. Application logic
      1. The Use Case/User Story modeling
      2. Stateful or stateless
    3. Domain logic
      1. DDD techniques - Building Blocks
      2. Model levels
        1. Capacity
        2. Operations
        3. Policy – tuning the model
        4. Decision Support
  4. System architecture patterns
    1. DatAccess to data
      1. Repository
      2. ORM – range of applicability
        1. Traps of Lazy Loading – detection and fixing
        2. Optimistic locking, which will always work
    2. Inversion of Control – tested concept of building frameworks and systems
      1. Dependency Injection – the basis of modern frameworks
        1. Support for testability
        2. Practical techniques of use in order to achieve a flexibility of design
      2. Event driven systems
        1. Plug-in architecture
        2. Separation of the modules
        3. Increasing the system responsiveness
        4. Scaling
      3. Aspect Oriented Programming
    3. Web application architectures
      1. Classic n-layer architecture (variants)
      2. Command-query Responsibility Segregation
      3. Architecture supporting Domain Driven Design
      4. Scalable systems
  5. Testability – designing for TDD support
    1. The Specify First approach
    2. Behaviour Driven Development
    3. Designing for tests with the use of OO techniques
    4. Techniques for dependency reduction
    5. Use of the Dependency Injection
    6. Mapping a test pyramid on application layers
    7. Application of Stub and Mock
    8. Reducing the amount of testing accidents
      1. Separation of logic
      2. Functional objects


Download PDF

Trainers

Meet the experts who will conduct your training.

Tomasz Ducin

Thinking is difficult. That's why most people judge. (Carl Jung)

Łukasz Szydło

Praktyka czyni mistrza

Paweł Szymczyk

Contact us for a free consultation.

Firstname and lastname:
Company:
E-mail:
Phone:
Subject:
Message:

If you prefer direct contact then you can always call.

Iwona Sobótka

Training coordinator


I agree to the processing of my personal data in accordance with the Law on the Protection of Personal Data in connection with sending a request via the contact form.

Providing the data is voluntary but necessary to process the query. I have been informed that I have the right to access my data, the possibility of correcting them, demanding stopping their processing.

The administrator of personal data is Bottega IT Minds, ul. Jana Sawy 2, 20-632 Lublin, Poland.

The information clausule