Software Estimation Tools and Technique

Important Concept to Understand:

1. Software Sizing
• In order to perform software estimation, first you needed understand what is software size and how to perform appropriate software sizing
1. Function point
2. Use case point
3. Object Point
4. Mark II function point analysis
5. Software size units
2. Effort Estimation
3. Productivity 

APPROPRIATE SOFTWARE-SIZING TECHNIQUE:

• Try using function points. This technique is by far the most popular and most widely used, but first you need to learn it. Many free, downloadable resources are available on the Internet for self-teaching

• Use task-based estimation. This is simply estimating the effort required for each of the components in the work breakdown structure to arrive at the total effort needed for the project. This technique is explained in subsequent chapters.

When the actual effort varies from the estimated effort by more than chance variation (that is, by more than 10 percent), the following could be the reasons:

• The actual size of the software produced varies from the estimated software size
• While the estimate assumes average skill and average effort, the allocation of manpower could result in predominantly poorly skilled (or super-skilled) manpower for the project execution
• Project execution could be sloppy (or excellent)
• Estimation norms could be wrong

Software Architectural book references

1. Building Evolutionary Architectures: Support Constant Change 1st Edition
by Neal Ford

2. Design It!: From Programmer to Software Architect (The Pragmatic Programmers) 1st Edition
by Michael Keeling

3. Patterns of Enterprise Application Architecture 1st Edition
by Martin Fowler

4. Clean Architecture: A Craftsman's Guide to Software Structure and Design 1st Edition
by Robert C. Martin

5. Microservice Patterns and Best Practices: Explore patterns like CQRS and event sourcing to create scalable, maintainable, and testable microservices Paperback – January 31, 2018
by Vinicius Feitosa Pacheco

6. Microservices Patterns: With examples in Java 1st Edition
by Chris Richardson

7. Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems 1st Edition
by Martin Kleppmann

8. Web Scalability for Startup Engineers 1st Edition
by Artur Ejsmont

9. Domain-Driven Design: Tackling Complexity in the Heart of Software Hardcover – Aug 20 2003
by Eric Evans

Maven: Basics

Why Maven?

Let's look what are the things a everyday developer does:

1. Write Code
2, Add library to the Project
2. Compile Code
3. Run unit test
4. Package Code  (Jar,War,Ear etc)
5. Deploy the binary to to Production or Test environment (Tomcat Jetty etc)

This whole thing can be automated using Maven.

Concept Must Understand :

1. POM(Project Object Model)
2. Super POM
3.Parent POM
4.Plug-in
5.Repository
6.Dependency
7.Transitive Dependencies
8.Maven Archetypes
9. Maven Directory Structure

Important Notes: If you execute any command in the life cycle maven will execute all the prior commands before executing the command. for example if you run "Test" Command maven will first run validate and compile command then it will run the Test Command .

Good to know Maven Concept :

1. Scope of a Dependency
2. Effective POM
4. Effective Settings
5. Dependency Hierarchy
6. Versioning of Dependency
7. Plug-in Goals
8. Plug-in Phase
9.Multi Module Maven Project

will continue...

Difference between Flowchart diagrams vs. UML activity diagrams

What is the practical difference between using flowchart diagrams and UML activity diagrams? I have some thoughts, but maybe I'm missing an elephant in the room?

Flowchart diagram:

1. Widely used;
2. Easily understood by non-programmers;
3. Old?

UML Activity diagram:

1. Standardized;
2. Supports concurrency;
3. Less known syntax, but still simple enough.

For my case of ad-hoc documenting a particular block of application logic, I decided to go with the flowchart diagrams. More people in the company will be able to understand them.

Maven: Difference between plugins and dependencies

In Maven POM file we can define both plugins and dependencies which could be little confusing
sometime to understand the difference.

Both plugins and dependencies are Jar files.

But the difference between them is, most of the work in maven is done using plugins; whereas dependency is just a Jar file which will be added to the classpath while executing the tasks.

For example, you use a compiler-plugin to compile the java files. You can't use compiler-plugin as a dependency since that will only add the plugin to the classpath, and will not trigger any compilation. The Jar files to be added to the classpath while compiling the file, will be specified as a dependency.

Same goes with your scenario. You have to use spring-plugin to execute some spring executables [ I'm not sure what spring-plugins are used for. I'm just taking a guess here ]. But you need dependencies to execute those executables. And Junit is tagged under dependency since it is used by surefire-plugin for executing unit-tests.

So, we can say, plugin is a Jar file which executes the task, and dependency is a Jar which provides the class files to execute the task.

https://stackoverflow.com/questions/11881663/what-is-the-difference-in-maven-between-dependency-and-plugin-tags-in-pom-xml