UML,HLD and LLD.


UML is a standard language for specifying, visualizing, constructing, and documenting the artifacts of software systems. Here is a Complete understanding of UML. http://www.tutorialspoint.com/uml/index.html

 High Level Design (HLD) is the overall system design - covering the system architecture and database design. It describes the relation between various modules and functions of the system. data flow, flow charts and data structures are covered under HLD.

 Low Level Design (LLD) is like detailing the HLD. It defines the actual logic for each and every component of the system. Class diagrams with all the methods and relation between classes comes under LLD. Programs specs are covered under LLD.


In HLD, you design the component level abstractions and interactions. In LLD, for each component, you go to the lower level such as class and method levels, describe what each class's responsibility, its interface and its interaction with other classes.

All terms like "high" and "low" are relative to the level of abstraction you're working in.

High level designs something using "abstractions" -- summaries, models, etc. Some times you use UML. Some times you use powerpoint. Some times you use screen shots. Some times you use fragments of code.

Low level designs ways to implement the abstractions. Some times you use UML. Some times you use powerpoint. Some times you use screen shots. Some times you use fragments of code.

"High level" could mean anything, anything at all. You could be designing an application to run a related collection of web sites. The high level design involves big components like "Apache", "Squid", "Wackamole", "MySQL". This is sometimes called "architecture" because there isn't much new code involved.

High level could mean designing a generic web application server that could be used by multiple customers, and is built on existing technology like Apache and Django. This would involve generic libraries of reusable code components.

High level could mean designing a specific web application for serving advertising images. You might use UML. This would involve some specific use cases and a specific web server framework, but would still be high level design of modules, packages, classes and databases to provide the required use cases.

High level could mean sketching out the tables and indexes required in a database. You might use UML. Low level design could be the actual columns and data types as well as the Object-Relational Mapping.

High level could mean sketching out the classes required to support a use case. You might start with a screen sheet. Low level design could be the actual method functions to implement the classes.

High level could mean sketching out the post-conditions for a method function. You might use code fragments. Low level could mean writing the actual code of the method functions.

High level and low level are relative terms. They are relative to what abstractions you're working with.

Source: StackOverflow

Comments

Post a Comment

Popular posts from this blog

How SQL Indexes Work internally ?

Image
When an index is created, it records the location of values in a table that are associated with the column that is indexed. Entries are added to the index when new data is added to the table. When a query is executed against the database and a condition is specified on a column in the WHERE clause that is indexed, the index is first searched for the values specified in the WHERE clause. If the value is found in the index, the index returns the exact location of the searched data in the table. Figure 16.1 illustrates how an index functions. Suppose the following query was issued: SELECT *  FROM TABLE_NAME WHERE NAME = 'SMITH'; As shown in Figure 16.1, the NAME index is referenced to resolve the location of all names equal to 'SMITH'. After the location is determined, the data can be quickly retrieved from the table. The data, in this case names, is alphabetized in the index. A full table scan would occur if there were no index on the table and the same que...
Read more

Mutable and Immutable Objects

Mutable Objects:  When you have a reference to an instance of an object, the contents of that instance  can  be altered Immutable Objects:  When you have a reference to an instance of an object, the contents of that instance  cannot  be altered Immutability and Instances To demonstrate this behaviour, we'll use  java.lang.String  as the immutable class and  java.awt.Point  as the mutable class. Point myPoint = new Point( 0, 0 ); System.out.println( myPoint ); myPoint.setLocation( 1.0, 0.0 ); System.out.println( myPoint ); String myString = new String( "old String" ); System.out.println( myString ); myString.replaceAll( "old", "new" ); System.out.println( myString ); In case you can't see what the output is, here it is: java.awt.Point[0.0, 0.0] java.awt.Point[1.0, 0.0] old String old String We are only looking at a single instance of each object, but we can see that the contents of  myPoint  has change...
Read more