Programming Applications & Frameworks.




1.    Compare and contrast declarative and imperative  paradigms.

Imperative Paradigms.
The answer is to use the emergency programming language to perform the necessary commands. To do this, we will use the declaration that can change the status of the application.
In mandatory programming, assignment statements are used to retrieve information in the memory for later use. When using loop statements, it allows execution of order sequences. If you want to confirm if any condition is met before any action, you can use the conditioned spelling statements.
To understand how this paradigm works, let's consider a small example. Suppose a user needs to change the color of the button after clicking on it. In terms of obligatory parasitism, we need to know how we should do it. Therefore, we need to examine and condition the condition of the component. Sample code
if(user.likes()){
    if(!hasBlue()) {
        removeRed();
    addBlue();
}
} else {    if(hasBlue()){
        removeBlue();
    addGrey();
    }
}

As you can see, we use the statement to prove what is currently visible on the screen. Then, in the information received, we carry out some type of activity.
If you have thirty of these products, it can be difficult to understand what is happening at first glance. The code must be analyzed to see what this code is, as if it were an interpreter. In addition, this code is associated with a specific context, which means that it will be difficult to use it again in another project.
Imperative programming is probably the most widely spread paradigm. The most popular examples of imperative programming languages are C++, Java, and PHP. The main characteristics of such programming languages are direct assignments, common data structures, and global variables.
But despite the high popularity level, we have to admit that imperative programming languages can be non-scalable and sometimes too complicated. Moreover, they’re more error-prone than declarative programming languages.


Declarative Paradigms.

The published program is often in the opposite direction to the program. In summary, this paradigm allows you to say what you want to do.

The development of this fashion describes the logic of the calculation, but it is not the flow of control. Only the results you can get from the application (they are more ways to get this result), can reduce unwanted side effects. The developers describe the results that must be obtained without a clear description of the steps involved.

To better understand what we mean, let's go to the example button above. Using the published language and the React library, it can be as follows:


if(this.state.liked){

  return <blueLike />;
} else {
  return <redLike />;
}
In this example, we’re focused on the UI for a given state. There’s no need in extra checking. We just say what we want our application to do. Without a doubt, now it’s easier to understand what’s going on.
The examples of declarative languages that’ll help you understand the concept are SQL and HTML. When you use one of those, you just describe your goals without specifying how you want to achieve them.
The declarative programming paradigm is much simpler to understand and much safer to use. It’s more scalable and provides you with the possibility to reuse your code. Don’t want to worry about the implementation details.
But those declarative and imperative approaches are essences from two different universes. Many declarative implementations have some sort of imperative abstraction layer.
When you use a UI library that follows the declarative programming paradigm, you assume that it knows how to perform all required steps to make the things done.





2.    Discuss the difference between procedural programming and functional programming.




Procedural Programming.
Procedural Programming uses a list of instructions to inform the computer step by step. The operation depends on the programming of the program. A set of computerized procedures to follow. Procedural programming is referred to as mandatory or structural programming.
The procedure is similar to the one you work with instead of using the program. If you want to do something with a computer, follow the instructions step by step. Most of the original programming languages are procedural. Synthetic languages include Friedrich, Cobb and C from the 1960s to the 1970s.
A common way of a procedural program is to repeat a series of steps to restore it. This means that you are writing a series of steps and then repeating this step over and over again. This can be done to restore the job.


Functional Programming.
Functional programming is an approach to solve each count as a mathematical function. The output of the function depends only on the values ​​given as an input, and does not depend on the steps previously followed.

Exercise is timely depiction. A rehabilitation function can be rehabilitated until a certain condition is reached. This is similar to using a real-time program. But today it is used for single action for a set of measures. Examples of Action Programming Languages ​​are Erlang, Haskell, Lisp and Scala.




3.    Explain the Lambda calculus and Lambda expressions in functional programming.

Lambda calculus is a framework developed by Alonzo Church in 1930s to study computations with functions.
  • Function creation − Church introduced the notation λx.E to denote a function in which ‘x’ is a formal argument and ‘E’ is the functional body. These functions can be of without names and single arguments.
  • Function application − Church used the notation E1.E2 to denote the application of function E1 to actual argument E2. And all the functions are on single argument.
Syntax of Lambda Calculus
Lamdba calculus includes three different types of expressions, i.e.,
E :: = x(variables)
| E1 E2(function application)
| λx.E(function creation)
Where λx.E is called Lambda abstraction and E is known as λ-expressions.
Evaluating Lambda Calculus
Pure lambda calculus has no built-in functions. Let us evaluate the following expression −
(+ (* 5 6) (* 8 3))
Here, we can’t start with '+' because it only operates on numbers. There are two reducible expressions: (* 5 6) and (* 8 3).
We can reduce either one first. For example −
(+ (* 5 6) (* 8 3))
(+ 30 (* 8 3))
(+ 30 24)
= 54


β-reduction Rule

We need a reduction rule to handle  λs
(λx . * 2 x) 4 
(* 2 4) 
= 8
This is called β-reduction.
The formal parameter may be used several times −
(λx . + x x) 4 
(+ 4 4) 
= 8
When there are multiple terms, we can handle them as follows −
(λx . (λx + (− x 1)) x 3) 9
The inner x belongs to the inner λ and the outer x belongs to the outer one.
(λx . + (− x 1)) 9 3 
+ (− 9 1) 3 
+ 8 3 
= 11

Free and Bound Variables

In an expression, each appearance of a variable is either "free" (to λ) or "bound" (to a λ).
β-reduction of (λx . E) y replaces every x that occurs free in E with y. For Example −

Alpha Reduction

Alpha reduction is very simple and it can be done without changing the meaning of a lambda expression.
λx . (λx . x) (+ 1 x) ↔ α λx . (λy . y) (+ 1 x)
For example −
(λx . (λx . + (− x 1)) x 3) 9 
(λx . (λy . + (− y 1)) x 3) 9 
(λy . + (− y 1)) 9 3 
+ (− 9 1) 3 
+ 8 3 
11

Church-Rosser Theorem

The Church-Rosser Theorem states the following −
·       If E1 ↔ E2, then there exists an E such that E1 → E and E2 → E. “Reduction in any way can eventually produce the same result.”
·       If E1 → E2, and E2 is normal form, then there is a normal-order reduction of E1 to E2. “Normal-order reduction will always produce a normal form, if one exists.”

Lazy evaluation is an evaluation strategy which holds the evaluation of an expression until its value is needed. It avoids repeated evaluation. Haskell is a good example of such a functional programming language whose fundamentals are based on Lazy Evaluation.
Lazy evaluation is used in Unix map functions to improve their performance by loading only required pages from the disk. No memory will be allocated for the remaining pages.

Lazy Evaluation − Advantages

·       It allows the language runtime to discard sub-expressions that are not directly linked to the final result of the expression.
·       It reduces the time complexity of an algorithm by discarding the temporary computations and conditionals.
·       It allows the programmer to access components of data structures out-of-order after initializing them, as long as they are free from any circular dependencies.
·       It is best suited for loading data which will be infrequently accessed.

Lazy Evaluation − Drawbacks

·       It forces the language runtime to hold the evaluation of sub-expressions until it is required in the final result by creating thunks (delayed objects).
·       Sometimes it increases space complexity of an algorithm.
·       It is very difficult to find its performance because it contains thunks of expressions before their execution.

Lazy Evaluation using Python

The range method in Python follows the concept of Lazy Evaluation. It saves the execution time for larger ranges and we never require all the values at a time, so it saves memory consumption as well. Take a look at the following example.
r = range(10) 
print(r) 
range(0, 10) 
print(r[3])
It will produce the following output −   [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 3

Functional programming languages are specially designed to handle symbolic computation and list processing applications. Functional programming is based on mathematical functions. Some of the popular functional programming languages include: Lisp, Python, Erlang, Haskell, Clojure, etc.
Functional programming languages are categorized into two groups, i.e. −
·       Pure Functional Languages − These types of functional languages support only the functional paradigms. For example − Haskell.
·       Impure Functional Languages − These types of functional languages support the functional paradigms and imperative style programming. For example − LISP.

Functional Programming – Characteristics

The most prominent characteristics of functional programming are as follows −
·       Functional programming languages are designed on the concept of mathematical functions that use conditional expressions and recursion to perform computation.
·       Functional programming supports higher-order functions and lazy evaluation features.
·       Functional programming languages don’t support flow Controls like loop statements and conditional statements like If-Else and Switch Statements. They directly use the functions and functional calls.
·       Like OOP, functional programming languages support popular concepts such as Abstraction, Encapsulation, Inheritance, and Polymorphism.

Functional Programming – Advantages

Functional programming offers the following advantages −
·       Bugs-Free Code − Functional programming does not support state, so there are no side-effect results and we can write error-free codes.
·       Efficient Parallel Programming − Functional programming languages have NO Mutable state, so there are no state-change issues. One can program "Functions" to work parallel as "instructions". Such codes support easy reusability and testability.
·       Efficiency − Functional programs consist of independent units that can run concurrently. As a result, such programs are more efficient.
·       Supports Nested Functions − Functional programming supports Nested Functions.
·       Lazy Evaluation − Functional programming supports Lazy Functional Constructs like Lazy Lists, Lazy Maps, etc.
As a downside, functional programming requires a large memory space. As it does not have state, you need to create new objects every time to perform actions.
Functional Programming is used in situations where we have to perform lots of different operations on the same set of data.
·       Lisp is used for artificial intelligence applications like Machine learning, language processing, Modeling of speech and vision, etc.
·       Embedded Lisp interpreters add programmability to some systems like Emacs.

Functional Programming vs. Object-oriented Programming

The following highlights the major differences between functional programming and object-oriented programming 

 Functional programming
  • Uses Immutable data.
  • Follows Declarative Programming Model.
  • Focus is on: “What you are doing”
  • Supports Parallel Programming
  • Its functions have no-side effects
  • Flow Control is done using function calls & function calls with recursion
  • It uses "Recursion" concept to iterate Collection Data.
  • Execution order of statements is not so important.
  • Supports both "Abstraction over Data" and "Abstraction over Behavior"


OOP


  • Uses Mutable data.
  • Follows Imperative Programming Model.
  • Focus is on “How you are doing”
  • Not suitable for Parallel Programming
  • Its methods can produce serious side effects.
  • Flow control is done using loops and conditional statements.
  • It uses "Loop" concept to iterate Collection Data. For example: For-each loop in Java
  • Execution order of statements is very important.
  • Supports only "Abstraction over Data".

The factors that affect the efficiency of a program includes −
Efficiency of a Program Code 
The efficiency of a programming code is directly proportional to the algorithmic efficiency and the execution speed. Good efficiency ensures higher performance.
  • The speed of the machine
  • Compiler speed
  • Operating system
  • Choosing right Programming language
  • The way of data in a program is organized
  • Algorithm used to solve the problem
The efficiency of a programming language can be improved by performing the following tasks −
·       By removing unnecessary code or the code that goes to redundant processing.
·       By making use of optimal memory and nonvolatile storage
·       By making the use of reusable components wherever applicable.
·       By making the use of error & exception handling at all layers of program.
·       By creating programming code that ensures data integrity and consistency.
·       By developing the program code that's compliant with the design logic and flow.
An efficient programming code can reduce resource consumption and completion time as much as possible with minimum risk to the operating environment.
                                                                                                                        
4.    What is meant by “no side-effects” and “referential transparency” in functional programming?


A functional programming (FP) idiom, and therefore a Scala/FP idiom, is that functions and methods should not have side effects. A method’s only act should be to compute and return a variable.
Again, this means that a function should not have any side effects. It should take input variables, not modify those variables, then calculate and return something new. Unlike object-oriented programming, you should not change (mutate) the state of other variables, even if those variables are (a) variables of your class or (b) variables that were passed in to your function/method.

Benefits of functions not having side effects

If you're new to functional programming this may sound pretty hard core, but as someone who has been working with Scala and functional programming for a few months now, I do find it a good practice to try to follow. Here's a short list of benefits from this Scala programming idiom:
1.     Methods are less entangled.
2.     They are therefore more reliable and reusable.
3.     You won't change someone's variable accidentally, and they won't change yours.
4.     Make your programs easier to test.
I started to write why each of these statements is true, but they all come down to the same things:
1.     Because you aren't mutating the variables passed to you, you can't corrupt their values.
2.     Because your function has no other side effects other than calculating a value based on its inputs, there are no side effects you need to test.

Implementing the “no side effects” idiom

A simple way to begin implementing this idiom is to treat all your function arguments as immutable "val" fields (the same as "final" in Java).
The second way to implement this idiom is to make sure your function returns some sort of value. As you'll see in the last section of this article, if a function doesn't return anything (it is defined as returning Unit), the question becomes, What is this function doing? Clearly it must have side effects if it accepts input but doesn't return anything.
The third step to implement this Scala idiom is to refactor your code mercilessly. The old rule still applies:
A function should do one thing, and only one thing.
If you follow that general programming idiom, along with these other suggestions, the "no side effects" idiom will make a lot of sense.



5.    Discuss the key features of Object Oriented Programming.

Features of OOP

OOP stands for Object Oriented Programming and the language that support this Object Oriented programming features is called Object oriented Programming Language. An example of a language that support this Object oriented features is C++.

Features of Object oriented Programming

The Objects Oriented programming language supports all the features of normal programming languages. In addition it supports some important concepts and terminology which has made it popular among programming methodology.

The important features of Object Oriented programming are:

·      Inheritance
·      Polymorphism
·      Data Hiding
·      Encapsulation
·      Overloading
·      Reusability

Let us see a brief overview of these important features of Object Oriented programming

But before that it is important to know some new terminologies used in Object Oriented programming namely

·      Objects
·      Classes


Objects:
In other words object is an instance of a class.
Classes:
These contain data and functions bundled together under a unit. In other words class is a collection of similar objects. When we define a class it just creates template or Skelton. So no memory is created when class is created. Memory is occupied only by object.

Example:
 Class classname
    {
        Data
        Functions
    };
    main ( )
    {
        classname objectname1,objectname2,..;
    }

In other words classes acts as data types for objects.
Member functions:

The functions defined inside the class as above are called member functions.
Here the concept of Data Hiding figures
Data Hiding:

This concept is the main heart of an Object oriented programming. The data is hidden inside the class by declaring it as private inside the class. When data or functions are defined as private it can be accessed only by the class in which it is defined. When data or functions are defined as public then it can be accessed anywhere outside the class. Object Oriented programming gives importance to protecting data which in any system. This is done by declaring data as private and making it accessible only to the class in which it is defined. This concept is called data hiding. But one can keep member functions as public.

So above class structure becomes

Example:

    Class classname
    {
        private:
        datatype data;
  
        public:
        Member functions
    };
    main ( )
    {
        classname objectname1,objectname2,..;
    }

Encapsulation:

The technical term for combining data and functions together as a bundle is encapsulation.

Inheritance:

Inheritance as the name suggests is the concept of inheriting or deriving properties of an existing class to get new class or classes. In other words we may have common features or characteristics that may be needed by number of classes. So those features can be placed in a common tree class called base class and the other classes which have these characteristics can take the tree class and define only the new things that they have on their own in their classes. These classes are called derived class. The main advantage of using this concept of inheritance in Object oriented programming is it helps in reducing the code size since the common characteristic is placed separately called as base class and it is just referred in the derived class. This provide the users the important usage of terminology called as reusability

Reusability:

This usage is achieved by the above explained terminology called as inheritance. Reusability is nothing but re- usage of structure without changing the existing one but adding new features or characteristics to it. It is very much needed for any programmers in different situations. Reusability gives the following advantages to users
It helps in reducing the code size since classes can be just derived from existing one and one need to add only the new features and it helps users to save their time.
For instance if there is a class defined to draw different graphical figures say there is a user who want to draw graphical figure and also add the features of adding color to the graphical figure. In this scenario instead of defining a class to draw a graphical figure and coloring it what the user can do is make use of the existing class for drawing graphical figure by deriving the class and add new feature to the derived class namely add the feature of adding colors to the graphical figure.

Polymorphism and Overloading:

Poly refers many. So Polymorphism as the name suggests is a certain item appearing in different forms or ways. That is making a function or operator to act in different forms depending on the place they are present is called Polymorphism. Overloading is a kind of polymorphism. In other words say for instance we know that +, – operate on integer data type and is used to perform arithmetic additions and subtractions. But operator overloading is one in which we define new operations to these operators and make them operate on different data types in other words overloading the existing functionality with new one. This is a very important feature of object oriented programming methodology which extended the handling of data type and operations.
6.    How the event-driven programming is different from other programming paradigms?


Event-driven programming
Event-driven programming is a programming paradigm in which the flow of program execution is determined by events - for example a user action such as a mouse click, key press, or a message from the operating system or another program. An event-driven application is designed to detect events as they occur, and then deal with them using an appropriate event-handling procedure. The idea is an extension of interrupt-driven programming of the kind found in early command-line environments such as DOS, and in embedded systems (where the application is implemented as firmware).
Event-driven programs can be written in any programming language, although some languages(Visual Basic for example) are specifically designed to facilitate event-driven programming, and provide an integrated development environment (IDE) that partially automates the production of code, and provides a comprehensive selection of built-in objects and controls, each of which can respond to a range of events. Virtually all object-oriented and visual languages support event-driven programming. Visual Basic, Visual C++ and Java are examples of such languages.
A visual programming IDE such as VB.Net provides much of the code for detecting events automatically when a new application is created. The programmer can therefore concentrate on issues such as interface design, which involves adding controls such as command buttons, text boxes, and labels to standard forms (a form represents an application's workspace or window). Once the user interface is substantially complete, the programmer can add event-handling code to each control as required.
Many visual programming environments will even provide code templates for event-handlers, so the programmer only needs to provide the code that defines the action the program should take when the event occurs. Each event-handler is usually bound to a specific object or control on a form. Any additional subroutines, methods, or function procedures required are usually placed in a separate code module, and can be called from other parts of the program as and when needed.






It’s very popular Because,
On the business development side, keeping the user engaged with your program is one clear way of making sure your app is actively used and offers value, so it makes sense to build your applications with this focus in mind.
Event-driven programming serves the user with the quickest and most accurate responses and this usually translates into better user experience and business gains. Also, the whole focus of software development is on the actual people using the app and their actions, so it will produce better and more intuitive products for the end-users.
The opposite of event-driven programming would be software that doesn’t need any user input to act. There are definitely valid use cases for this as well but the majority of popular applications on the market right now function through user input (all the social media platforms, games, productivity tools, etc).



7.    Compare and contrast the Compiled languages, Scripting languages, and Markup languages.

Compiled Language
A compiled language is a programming language whose implementations are typically compilers (translators that generate machine code from source code), and not interpreters (step-by-step executors of source code, where no pre-runtime translation takes place).
The term is somewhat vague. In principle, any language can be implemented with a compiler or with an interpreter. A combination of both solutions is also common: a compiler can translate the source code into some intermediate form (often called p-code or bytecode), which is then passed to an interpreter which execute.

Markup Language

This is debatable, but markup language is not considered to be a programming language simply because the term is not well-defined. A markup language is used to control the presentation of the data, like representing structured data. For example, HTML is used to specify that some part of a document is a title, another part is a list, another part is heading etc. So, based off of that, a markup language is used to describe the data and the formatting in a textual format. There is a general rule, that a markup language will not describe a process or an algorithm (like programming language does) but is just pure data.

Scripting Languages

A scripting language is a type of language that is designed to integrate and communicate with other programming languages. Examples of commonly used scripting languages include JavaScript, VBScript, PHP among others. There are mostly used in conjunction with other languages, either programming or markup languages. For example, PHP which is a scripting language is mostly used in conjunction with HTML. It is safe to say that all scripting languages are programming languages, but not all programming languages are scripting languages.
One of the differences between scripting languages and programming languages is in terms of compilation. While it is a must for a programming to be compiled, scripting languages are interpreted without being compiled. It is important to note that scripting languages are interpreted directly from the source code.
Due to the absence of the compilation process, scripting languages are a bit faster than the programming languages. In recent years, we have seen a widespread use of scripting languages in developing the client side of web applications.

8.    Discuss the role of the virtual runtime machines.

In computing, a virtual machine (VM) is an emulation of a computer system. Virtual machines are based on computer architectures and provide functionality of a physical computer. Their implementations may involve specialized hardware, software, or a combination.
There are different kinds of virtual machines, each with different functions:
  • System virtual machines (also termed full virtualization VMs) provide a substitute for a real machine. They provide functionality needed to execute entire operating systems. A hypervisor uses native execution to share and manage hardware, allowing for multiple environments which are isolated from one another, yet exist on the same physical machine. Modern hypervisors use hardware-assisted virtualization, virtualization-specific hardware, primarily from the host CPUs.
  • Process virtual machines are designed to execute computer programs in a platform-independent environment.
Some virtual machines, such as QEMU, are designed to also emulate different architectures and allow execution of software applications and operating systems written for another CPU or architecture. Operating-system-level virtualization allows the resources of a computer to be partitioned via the kernel. The terms are not universally interchangeable.

A machine is part of an environment, which are in turn part of a workspace. The workspace administration introduction explains the details of this relationship. A machine is created from a runtime stack. Supports both single-machine environments and multi-machine environments. The server manages the lifecycle of environments and the machines inside, including creating snapshots of machines. Additionally, the server can inject workspace agents into a machine to provide additional capabilities inside the machine.

9.    Find how the JS code is executed (What is the runtime? where do you find the interpreter?)

Runtime
The JavaScript Runtime (JsRT) APIs provide a way for desktop, Windows Store, and server-side applications running on the Windows operating system to add scripting capabilities to an app by using the standards-based Chakra JavaScript engine that is also utilized by Microsoft Edge and Internet Explorer. These APIs are available on Windows 10 and any version of the Windows operating system that has Internet Explorer version 11.0 installed on the machine.



10.    Explain how the output of an HTML document is rendered, indicating the tools used to display the output.
  
If you want to write semantic markup – and believe us,You do want to write seminastic markup then you need to structure HTML documents properly. The html, head, and body elements have been part of the HTML specification since the mid 1990s, and up until a few years ago they were the primary elements used to give structure to HTML documents. However, the situation has changed dramatically in the last few years as HTML5 has added a slew of new tags that can be used to add rich semantic meaning to the structure of an HTML document.

HTML Document Structure Before HTML5

If you've been using HTML for any time at all you know that every bit of HTML needs to be wrapped in html tags. An opening <html> tag should appear first and a closing </html> tag should appear at the bottom of the document. Every other bit of HTML should appear between those two tags.
The head element is the first element to appear after the opening html tag. In the document head we place things like the page title and meta data, we add JavaScript to our page with the script tag, and we [link] to external stylesheets and other resources.
All of the content that is visible on a web page is nested between opening and closing body tags. The body is the primary container of the content that makes up a web page.
Up until HTML5, that was pretty much it for basic HTML document structure. All of our code was dropped in between the body tags and styled with CSS. However, now that HTML5 has broad support among modern browsers, it's time to implement the new HTML5 tags that will give our HTML documents a much more meaningful structure.

New Semantic Tags Added by HTML5

In this brief tutorial we'll touch on all of the new tags added as part of HTML5 to define the structure and content of a web page. The elements we're going to cover in this guide include:

Using these elements isn't as complicated as it might appear at first glance, and most are fairly self-explanatory. We'll make a quick pass over each new element, and then draw up an HTML template you can use these new tags to add rich semantic meaning to your markup.

  • The HTML Output element (<output>) is a container element into which a site or app can inject the results of a calculation or the outcome of a user action.




 11.    Identify different types of CASE tools, Workbenches, and Environments for different types of software systems (web-based systems, mobile systems, IoT systems, etc.).


CASE Tools
Computer-Aided Software Engineering (CASE) technologies are tools that provide automated assistance for software development . The goal of introducing CASE tools is the reduction of the time and cost of software development and the enhancement of the quality of the systems developed. The interest in CASE tools and environments is based on expectations about increasing productivity, improving product quality, facilitating maintenance, and making software engineers' task less odious and more enjoyable. A survey of the CASE tool market  showed that the annual worldwide market for CASE fools was $4.8 billion in 1990 and grew to $12.11 billion in 1995. Behind such a prosperous CASE market, however, another result gained from the real investigation about the use of CASE tools revealed that CASE tools seem to be sparsely used after being bought in many enterprises.

CASE is the use of computer-based support in the software development process; a CASE tool is a computer-based product aimed at supporting one or more software engineering activities within a software development process; a CASE environment is a collection of CASE tools and other components together with an integration approach that supports most or all of the interactions that occur among the environment components, and between the users of the environment and the environment itself.


Workbenches

In the sequence of comprehension testing techniques, we must know the concept of workbench. Normally a workbench concept is a method of scheduling that how a particular action has to be executed. Workbench concept normally contains the following actions mentioned as below:-
  •  Input
  •  Execute
  •  Check
  •  Production Output
  •  Rework

Environments for different types of software systems

Web based systems:
Software environments accessible via Web browser, containing an integrated set of tools and functionalities.


Mobile systems:
Is a computing system with mobile entities. These entities can be either software or hardware.



IOT Systems:


The Internet of Things (IoT) is a system of interrelated computing devices, mechanical and digital machines, objects, animals or people that are provided with unique identifiers and the ability to transfer data over a network without requiring human-to-human or human-to-computer interaction.
A complete IoT system integrates four distinct components: sensors/devices, connectivity, data processing, and a user interface. Below I will briefly explain each component and what it does.


12.    Discuss the difference between framework, library, and plugin, giving some examples
A library performs specific, well-defined operations.
A framework is a skeleton where the application defines the "meat" of the operation by filling out the skeleton. The skeleton still has code to link up the parts but the most important work is done by the application.
A Plugins extends the capabilities of a larger application. That sounds exactly like what your address book is doing.
Examples of libraries: Network protocols, compression, image manipulation, string utilities, regular expression evaluation, math. Operations are self-contained.
Examples of frameworks: Web application system, Plug-in manager, GUI system. The framework defines the concept but the application defines the fundamental functionality that end-users care about.

Examples of plugins: 
Adobe Flash Player
Java
QuickTime Player
Microsoft Silver light







Comments

Post a Comment