Sunday, August 26, 2018

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


Monday, August 20, 2018

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

Thursday, August 9, 2018

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.

Monday, August 6, 2018

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.

Tuesday, July 17, 2018

Important Jira/Confluence plug-in

1. Tempo Timesheets


Painless time tracking, powerful reporting, better overview of time spent on projects and throughout your organization




2. Balsamiq Wire-frames 


Life's too short for bad software! Add wireframes and simple prototypes to your Confluence pages and design delightful interfaces


3. Gliffy Diagram for Confluence

Diagrams Made Easy – Gliffy Diagrams for Confluence Improves Your Team’s Ability to Communicate and Collaborate Visually



Tuesday, July 10, 2018

What is the Different between JSON and YAML?

JSON  =  Java script object notation. 

What It Is:
JSON (JavaScript Object Notation) is a lightweight data-interchange format. It is easy for humans to read and write. It is easy for machines to parse and generate. It is based on a subset of the JavaScript Programming Language,Standard ECMA-262 3rd Edition - December 1999. JSON is a text format that is completely language independent but uses conventions that are familiar to programmers of the C-family of languages, including C, C++, C#, Java, JavaScript, Perl, Python, and many others. These properties make JSON an ideal data-interchange language.

More details here: 

https://www.json.org/

YAML = YAML Ain't Markup Language
What It Is:
 YAML is a human friendly data serialization  standard for all programming languages.

More Details here:
http://yaml.org/




Sample JSON:

  • { "QueryResponse": { "maxResults": 1, "startPosition": "1", "Employee": { "Organization": false, "Title": "Mrs.", "GivenName": "Jane", "MiddleName": "Lane", "FamilyName": "Doe", "DisplayName": "Jane Lane Doe", "PrintOnCheckName": "Jane Lane Doe", "Active": true, "PrimaryPhone": { "FreeFormNumber": "505.555.9999" }, "PrimaryEmailAddr": { "Address": "janedoe@example.com" }, "EmployeeType": "Regular", "status": "Synchronized", "Id": "ABC123", "SyncToken": 1, "MetaData": { "CreateTime": "2015-04-26T19:45:03Z", "LastUpdatedTime": "2015-04-27T21:48:23Z" }, "PrimaryAddr": { "Line1": "123 Any Street", "City": "Any City", "CountrySubDivisionCode": "WA", "PostalCode": "01234" } } }, "time": "2015-04-27T22:12:32.012Z" }
Sample YAML
  • --- QueryResponse: maxResults: 1 startPosition: '1' Employee: Organization: false Title: Mrs. GivenName: Jane MiddleName: Lane FamilyName: Doe DisplayName: Jane Lane Doe PrintOnCheckName: Jane Lane Doe Active: true PrimaryPhone: FreeFormNumber: 505.555.9999 PrimaryEmailAddr: Address: janedoe@example.com EmployeeType: Regular status: Synchronized Id: ABC123 SyncToken: 1 MetaData: CreateTime: '2015-04-26T19:45:03Z' LastUpdatedTime: '2015-04-27T21:48:23Z' PrimaryAddr: Line1: 123 Any Street City: Any City CountrySubDivisionCode: WA PostalCode: '01234' time: '2015-04-27T22:12:32.012Z'

Relation to JSON

Both JSON and YAML aim to be human readable data interchange formats. However, JSON and YAML have different priorities. JSON’s foremost design goal is simplicity and universality. Thus, JSON is trivial to generate and parse, at the cost of reduced human readability. It also uses a lowest common denominator information model, ensuring any JSON data can be easily processed by every modern programming environment.

In contrast, YAML’s foremost design goals are human readability and support for serializing arbitrary native data structures. Thus, YAML allows for extremely readable files, but is more complex to generate and parse. In addition, YAML ventures beyond the lowest common denominator data types, requiring more complex processing when crossing between different programming environments.

YAML can therefore be viewed as a natural superset of JSON, offering improved human readability and a more complete information model. This is also the case in practice; every JSON file is also a valid YAML file. This makes it easy to migrate from JSON to YAML if/when the additional features are required.

JSON's RFC4627 requires that mappings keys merely “SHOULD” be unique, while YAML insists they “MUST” be. Technically, YAML therefore complies with the JSON spec, choosing to treat duplicates as an error. In practice, since JSON is silent on the semantics of such duplicates, the only portable JSON files are those with unique keys, which are therefore valid YAML files.

It may be useful to define a intermediate format between YAML and JSON. Such a format would be trivial to parse (but not very human readable), like JSON. At the same time, it would allow for serializing arbitrary native data structures, like YAML. Such a format might also serve as YAML’s "canonical format". Defining such a “YSON” format (YSON is a Serialized Object Notation) can be done either by enhancing the JSON specification or by restricting the YAML specification. Such a definition is beyond the scope of this specification


5 Strategies for Getting More Work Done in Less Time

Summary.    You’ve got more to do than could possibly get done with your current work style. You’ve prioritized. You’ve planned. You’ve dele...