Extract, transform and load (ETL) is a process in database usage and especially in data warehousing that involves:
Extracting data from outside sources
Transforming it to fit operational needs (which can include quality levels)
Loading it into the end target (database or data warehouse)
Microsoft Integration Services is a platform for building high performance data integration solutions, including extraction, transformation, and load (ETL) packages for data warehousing
Integration Services includes graphical tools and wizards for building and debugging packages; tasks for performing workflow functions such as FTP operations, executing SQL statements, and sending e-mail messages; data sources and destinations for extracting and loading data; transformations for cleaning, aggregating, merging, and copying data; a management service
http://msdn.microsoft.com/en-us/library/ms169917(v=sql.105).aspx
"ad hoc" reporting systems allow the users themselves to create specific, customized queries.
Typically this would be via a user-friendly GUI-based system without the need for the in-depth knowledge of SQL, or database schema that a programmer would have.
Because such reporting has the potential to severely degrade the performance of a live system, it is usually provided over a data warehouse.
Ad hoc querying/reporting is a business intelligence subtopic, along with OLAP, data warehousing, data mining and other tools.
http://en.wikipedia.org/wiki/Ad_hoc
An Ad-Hoc Query is a query that cannot be determined prior to the moment the query is issued.
It is created in order to get information when need arises and it consists of dynamically constructed SQL which is usually constructed by desktop-resident query tools.
http://www.learn.geekinterview.com/data-warehouse/dw-basics/what-is-an-ad-hoc-query.html
Information Technology (IT) departments for solutions to achieve greater efficiency and for business software to improve customer service
Business managers are always looking to compare the cost of IT solutions with the potential return on investment (ROI)
ERP, the Complete Business Solution
The biggest decision and most risky solution is that of an Enterprise Resource Planning system, or ERP.
This solution can be a complete replacement for all of the business software and procedures within the company by a single suite of programs that are specifically designed to efficiently manage assets and resources based around a comprehensive financial system
The benefit of ERP is having a single solution provider for everything from accounts through manufacturing and warehouse management to human resources.
Every package is linked to allow extensive business intelligence.
SCM for Efficient Management of the Supply Chain
Supply Chain Management as the "design, planning, execution, control, and monitoring of supply chain activities with the objective of creating net value, building a competitive infrastructure, leveraging worldwide logistics, synchronizing supply with demand, and measuring performance globally".
CRM, Customer Relationship Management
A CRM software solution provides a database where every piece of communication such as telephone call; email or direct conversation can be logged to ensure that promises can be met and leads can be efficiently followed.
This is especially important where a business has many customers or those that have a team of sale staff who may need to know the details of the last conversation.
-a storage area for processed and integrated data across different sources -operational and external data
-allows the users to extract data for business analysis and strategic decision making -supports management decision making process -stand-alone repository of information which is ingtegrated from several operational databases
Using the film industry as an analogy, the project manager is the producer (making sure things get done), whereas the architect is the director (making sure things get done correctly).
As the technical lead on the project, the characteristics and skills of the architect are typically broad, rather than deep
the architect is a technical leader, which means that, as well as having technical skills, the architect exhibits leadership qualities.
Leadership can be characterized in terms of both position in the organization and also in terms of the qualities that the architect exhibits.
the architect is the technical lead on the project and should have the authority to make technical decisions.
The project manager, on the other hand, is more concerned with managing the project plan in terms of resources, schedule, and cost
since the success of the architect is closely linked to the quality of the team, participation in interviewing new team members is also highly appropriate.
Successful architects are people-oriented, and every architect takes time to act as a mentor and coach to the members of their team.
"architect" refers to the role, which may be fulfilled by either an individual or a team.
If the architect role is to be fulfilled by a team, then it is important to have one individual who is considered the lead architect, who is responsible for owning the vision and can act as a single point of coordination across the architecture team
Good architects know their strengths and weaknesses
it is often the case that an architect is supported by a number of "trusted advisors."
Such architects acknowledge where they are weak and compensate for these weaknesses by either obtaining the necessary skills or working with other people to fill the gaps in their knowledge
Day-to-day, the development team will often look to the architect to tell them what to do and often how to do it
Therefore, a good architect will have a balance of software development knowledge and business domain knowledge
architects should have a certain level of programming skills, even if they do not necessarily write code.
Specifically, the architect should have effective language skills, including speaking, writing, and presentation abilities. Also, the communication is two-way. The architect should be a good listener and observer, as well as a good talker.
Communication with the project team is particularly important, since the architect is not simply responsible for conveying information to the team, but also for motivating them
An architect who is unable to make decisions in an environment where much is unknown, where there is insufficient time to explore all alternatives, and where there is pressure to deliver is unlikely to succeed. Such an environment is to be expected, and successful architects acknowledge the situation, rather than try to change it. Thus, the architect needs to be "thick-skinned" since they may need to correct their decisions and backtrack at times during a project
Successful architects are not geeks only concerned with technology.
Build durable architectures (Independence with regard to API/framework providers)
Promote genericity and abstraction
Bridge between developers, project managers, and business experts
Often mixed culture (.NET/J2EE/opensource)
the role is often close to the role of a technical expert.
An architect is often an ex-developer who has accumulated such experience as to reach a good level in expertise.
Communication skills are required.
Diplomacy and pedagogy skills are also required to be able to explain architectures, debate about them and have them adopted
An architect must be able to step back and take a higher-level look, which is often difficult for developers and projects managers because they are often too focused on a specific project and so on immediate needs
This means raising from the application level to the information system level.
an architect must be able to quickly read and analyze code.
An architect doesn’t take part to a project only at its beginning, but during the whole project’s lifecycle to ensure a right implementation of the design and architecture.
"Architects are a lot slower in getting a solution, especially if the problem is simple!"
primary duties of a chief software architect, including
duties of an architect
skills of an architect
knowledge required by an architect
duties of an organization to its architects and architecture-based development projects
Duties:
A good architect provides a development team with all of the tools they need to put together a great system.
Review and improve on existing systems, making use of new technologies and methodologies to seek continual improvement for existing systems.
Provide high level guidance and direction on project work, making sure tha new projects fit in with an overall strategic vision.
Strong communication with both technical and business teams
Some duties are common between them only difference is about orientation.
In which Project Manager aligned more toward Client interaction, People, Time & cost management.
An architect can be of any type based on organization structure and its hierarchy
An Architect must be good learner as Software Industry changing trands frequently
Provide guidance to others on how software should be built
abstracts the complexity of a system into a manageable model
Act as a consultant-strategist for everyone
he may have to wear multiple hats - as a "manager" to co-ordinate with all stakeholders, as a salesman to "sell" the idea behind his solution, as a "developer" to develop POC or pilot to prove that his solution will work, as an "executive" to drive through the implementation.
Skills:
An architect must be technically competent and a strong communicator (written, verbal, presentation...).
Ability to impart knowledge to others
Software is the living codification of ideas, brought together to achieve economic benefits for society and ultimately to bring enjoyment to individuals. Similar to living entities, software is subject to the forces of evolution and change, and ultimately has a mortality unless adaptation and growth is maintained.
The role of the chief software architect is understand, codify and communicate the forces of adaptation and change while maintaining the organizational balance between economic drivers and technical capabilities.
There are a number of different qualities that you can look for in a software architect
and their past experience is often a good gauge of their ability to undertake the role.
you need to look deeper to understand the level of involvement, influence, leadership and responsibility that has been demonstrated across a number of different areas.
All you have to do is figure out what the requirements are and design a system that satisfies them
Broadly speaking, the software architecture on most projects can be broken down into two phases; the architecture is defined and then it's delivered.
Delivery of the software architecture
Definition of the software architecture
Definition of the software architecture
the architecture definition part of the role can be broken down further into a number of different elements
Management of non-functional requirements
Non-functional requirements need to be specific, measurable, achievable and testable if we are going to satisfy them
Sometimes the stakeholders will tell us that "the system must be fast", but that's far too subjective
Architecture definition:
It's fair to say that every software system has an architecture,
but not every software system has a defined architecture.
The architecture definition process lets you think about how you're going to take the requirements along with any imposed constraints and solve the problem.
Architecture definition is about introducing structure, guidelines, principles and leadership to the technical aspects of a software project
Defining architecture is your job as a software architect but there's a big difference between designing a software system from scratch and extending an existing one.
Technology selection:
it does have its fair set of challenges when you look at cost, licensing, vendor relationships, technology strategy, compatibility, interoperability, support, deployment, upgrade policies, end-user environments and so on.
Architecture evaluation:
an architecture works if it satisfies the non-functional requirements,
provides the necessary foundation for the rest of the code
and provides a sufficient platform for solving the underlying business problem
If you can test your architecture, then you can prove that it works. And if you can do this as early as possible, you can reduce the overall risk of project failure rather than simply hoping for the best.
Architecture collaboration:
Delivery of the software architecture
Ownership of the bigger picture:
sells the vision throughout the entirety of the software development lifecycle,
If you've defined an architecture, it makes sense to remain continually engaged and evolve your architecture rather than choosing to hand it off to an "implementation team".
Leadership:
Owning the bigger picture is one aspect of technical leadership
These include taking responsibility, providing technical guidance, making technical decisions and having the authority to make those decisions.
Coaching and mentoring:
While technical leadership is about steering the project as a whole, there are times when individuals need assistance
coaching and mentoring provides a way to enhance people's skills and to help them improve their own careers.
there's a big difference between coaching your team in architecture and design versus helping them with their coding problems.
Quality assurance:
From a software development perspective, these could include
coding standards,
design principles and source code analysis tools through to the use of continuous integration, automated unit testing and code coverage tools.
Design, development and testing:
The last thing that falls squarely within the role of a software architect is design, development and testing.
why shouldn't the day-to-day coding activities be a part of an architect's role?
the architect can experience the same pain as everybody else on the team, which in turn helps them better understand how their architecture is viewed from a development perspective.
Are you a software architect?
there's a high probability that those same developers are already undertaking parts of the software architecture role, irrespective of their job title.
Core Technical Requirements
Software architects must have a background in coding software using one or more programming languages.
This coding experience will be with complex and large-scale solutions in a team environment.
Soft Skills
The software architect must have excellent interpersonal skills
Issues during performance testing often require the architect to determine root cause and design a solution
Who is Right for the Architect Role?
Too frequently, "architect" is a promotion offered to top-notch developers in an effort to retain them
The best architects, then, are good technologists and command respect in the technical community, but also are good strategists, organizational politicians (in the best sense of the word), consultants and leaders.
http://www.bredemeyer.com/who.htm
JVM Tuning & Troubleshooting - Türkçe - Gökhan Fazli Çelik - part 1 of 3
http://www.youtube.com/watch?v=yUJRMwiEK0E
From Java code to Java heap
the memory overhead of putting an int value into an Integer object, the cost of object delegation, and the memory efficiency of the different collection types
Oracle WebCenter Content provides organizations with a unified repository to house unstructured content, and deliver it to business users in the proper format, and within context of familiar applications to fit the way they work.
http://www.oracle.com/us/products/middleware/webcenter/content/overview/index.html
The Capability Maturity Model Integration (CMMI) is one of the leading models and based on best practice.
Independent assessments grade organizations on how well they follow their defined processes, not on the quality of those processes or the software produced
ISO 9000
ISO 9000 describes standards for a formally organized process to manufacture a product and the methods of managing and monitoring progress.
ISO/IEC 15504
ISO/IEC 15504 Information technology — Process assessment also known as Software Process Improvement Capability Determination (SPICE), is a "framework for the assessment of software processes".
The key characteristic of a Spiral model is risk management at regular stages in the development cycle
Iterative and incremental development
Iterative development prescribes the construction of initially small but ever-larger portions of a software project to help all those involved to uncover important issues early before problems or faulty assumptions can lead to disaster.
Agile development
Agile software development uses iterative development as a basis but advocates a lighter and more people-centric viewpoint than traditional approaches.
Agile processes use feedback, rather than planning, as their primary control mechanism.
The feedback is driven by regular tests and releases of the evolving software.
Extreme Programming (XP)
Scrum
Dynamic systems development method
Code and fix
Yazılım Süreci Modelleri
Süreçlere ilişkin ayrıntılarla ya da süreçler arası ilişkilerle ilgilenmezler.
Gelişigüzel Model
Barok Modeli
Çağlayan (Şelale) Modeli
V Modeli
Helezonik (Spiral) Model
Evrimsel Model
Artırımsal Model
Araştırma Tabanlı Model
https://docs.google.com/viewer?a=v&q=cache:h-uE4oVxKEkJ:metinakbulut.com/YAZILIM-MIMARISI/Bolum-02.ppt+&hl=en&pid=bl&srcid=ADGEESiVmUq28rel_uDufGt4hTrHCQJobcQWjz1uLDTfP1KdtLjfuTx16UMDgoKfKVPxsiUCvkMgGprNKDLuAGHyg7PCCwpQVsYqL4dIMBrwbjyYjc7-5SZ7k3i8lZk811DWSUMNY6pU&sig=AHIEtbSNh8MipDzJioe4jerIIEKNlu6IWQ
Software process models:
Waterfall model
Evolutionary development
Formal systems development
Reuse-based development
Hybrid software process models:
Incremental development
Spiral development
https://docs.google.com/viewer?a=v&q=cache:mzUVIL-enOoJ:ranger.uta.edu/~khalili/Chapter%25202%2520-%2520Software%2520Processes.ppt+&hl=en&pid=bl&srcid=ADGEESi6A2gA72cNC8G9XZUGMFbdp_KiBVyfImtHJ5fQkFFx5gMfiay2PqBy8dPVIWC2LtNxTJmKtyDsEOV1o0xzG5FK15XLMvuz7r7yw1wAGdU-cHsxsaSBTnIsUbh3sEaUXd8-VxQz&sig=AHIEtbTW9RfBAQsoyIn3uwsmbqdgsKu8rA
the key pros and cons of six of the most common SDLC methodologies
1. Waterfall Model
Waterfall is the oldest and most straightforward of the structured SDLC methodologies — finish one phase, then move on to the next. No going back. Each stage relies on information from the previous stage and has its own project plan.Waterfall is easy to understand and simple to manage. But early delays can throw off the entire project timeline. And since there is little room for revisions once a stage is completed, problems can’t be fixed until you get to the maintenance stage. This model doesn’t work well if flexibility is needed or if the project is long term and ongoing.
2. V-Shaped Model
Also known as the Verification and Validation model, the V-shaped model grew out of Waterfall and is characterized by a corresponding testing phase for each development stage. Like Waterfall, each stage begins only after the previous one has ended. This model is useful when there are no unknown requirements, as it’s still difficult to go back and make changes.
3. Iterative Model
Instead of starting with fully known requirements, you implement a set of software requirements, then test, evaluate and pinpoint further requirements. A new version of the software is produced with each phase, or iteration. Rinse and repeat until the complete system is ready.One advantage over other SDLC methodologies: This model gives you a working version early in the process and makes it less expensive to implement changes. One disadvantage: Resources can quickly be eaten up by repeating the process again and again.
4. Spiral Model
the Spiral model takes a cue from the Iterative model and its repetition; the project passes through four phases over and over in a “spiral” until completed, allowing for multiple rounds of refinement. This model allows for the building of a highly customized product, and user feedback can be incorporated from early on in the project. But the risk you run is creating a never-ending spiral for a project that goes on and on
5. Big Bang Model
the Big Bang model follows no specific process, and very little time is spent on planning. The majority of resources are thrown toward development, and even the client may not have a solid grasp of the requirements. This is one of the SDLC methodologies typically used for small projects with only one or two software engineers.
6. Agile Model
By breaking the product into cycles, the Agile model quickly delivers a working product and is considered a very realistic development approach. The model produces ongoing releases, each with small, incremental changes from the previous release. At each iteration, the product is tested.
This model emphasizes interaction, as the customers, developers and testers work together throughout the project. But since this model depends heavily on customer interaction, the project can head the wrong way if the customer is not clear on the direction he or she wants to go.
https://www.roberthalf.com/technology/blog/6-basic-sdlc-methodologies-the-pros-and-cons
Oracle Fusion Middleware 11g's hot-pluggable architecture allows you to make the most of your current investments in applications and technology, while also taking advantage of modern hardware and software architectures. The goal of this release is to maximize your efficiency in both IT and business processes to give you the agility to adapt and innovate
Business Process Execution Language (BPEL), short for Web Services Business Process Execution Language (WS-BPEL) is an OASIS standard executable language for specifying actions within business processes with web services.
BPEL is the standard for assembling a set of discrete services into an end-to-end process flow, radically reducing the cost and complexity of process integration initiatives
Oracle GoldenGate is a comprehensive software package for enabling the replication of data in heterogeneous data environments.
The product set enables high availability solutions, real-time data integration, transactional change data capture, data replication, transformations, and verification between operational and analytical enterprise systems
If you’ve tested Oracle GoldenGate and found it too complex and expensive, tried Streams only to discover it’s slow and nearing its EOL, or need more availability than Data Guard can provide, it’s time to check out a better solution.
SharePlex® for Oracle is a mature, high-performance, high-availability technology that offers a low-cost alternative to other Oracle replication tools.
This Oracle replication solution ensures business continuity while meeting your database operational goals.
It provides a real-time copy of production data – without impacting your OLTP system’s performance and availability.
Synchronization is a process of controlling the access of shared resources by the multiple threads in such a manner that only one thread can access a particular resource at a time.
In non synchronized multithreaded application, it is possible for one thread to modify a shared object while another thread is in the process of using or updating the object's value.
Synchronization prevents such type of data corruption which may otherwise lead to dirty reads and significant errors.
Windows Internet Name Service (WINS) is Microsoft's implementation of NetBIOS Name Service (NBNS), a name server and service for NetBIOS computer names.
Effectively WINS is to NetBIOS names what DNS is to domain names — a central mapping of host names to network addresses.
Like DNS it is broken into two parts, a Server Service (that manages the encoded Jet Database, server to server replication, service requests, and conflicts) and a TCP/IP Client component which manages the client's registration and renewal of names, and takes care of queries.
http://en.wikipedia.org/wiki/Windows_Internet_Name_Service
WINS was designed specifically to support NetBIOS over TCP/IP (NetBT).
WINS is required for any environment in which users access resources that have NetBIOS names.
If you do not use WINS in such a network, you cannot connect to a remote network resource by using its NetBIOS name unless you use Lmhosts files, and you might be unable to establish file and print sharing connections.
WINS and DNS are both name resolution services for TCP/IP networks.
While WINS resolves names in the NetBIOS namespace, DNS resolves names in the DNS domain namespace.
WINS primarily supports clients that run older versions of Windows and applications that use NetBIOS
Environments that include some computers that use NetBIOS names and other computers that use domain names must include both WINS servers and DNS servers
university of california,berkeley
https://hkn.eecs.berkeley.edu/exams/course/cs/162
CS411/511 - Operating Systems
Oregon State University
http://web.engr.oregonstate.edu/~pancake/cs411/
SUNUCU ISLETIM SISTEMI 2.DÖNEM 3.SINAV SORU VE CEVAPLARI
http://www.meslekogretmenleri.com/yazili_sorulari_cevap_anahtarlari/sunucu_isletim_sistemi_2donem_3sinav_soru_ve_cevaplari-t3947.0.html
WINDOWS ISLETIM SISTEMI SORULARI
http://www.eogretmen.com/windows_isletim_sistemi_sorulari.htm
What is the difference between multiprocessing, multiprogramming,multitasking and multithreading?
Multitasking:
The ability to execute more than one task at the same time
Tasks sharing a common resource (like 1 CPU)
More than one task/program/job/process can reside into the same CPU at one point of time.
This ability of the OS is called multitasking.
Multiprogramming:
The allocation of a computer system and its resources to more than one concurrent application, job or user
A computer running more than one program at a time (like running Excel and Firefox simultaneously)
More than one task/program/job/process can reside into the main memory at one point of time.
This ability of the OS is called multiprogramming.
Multithreading:
Executing more than one thread parallely using a single processor
Multiprocessing:
Simultaneous execution of instructions by multiple processors within a single computer
A computer using more than one CPU at a time
FreeMarker is a "template engine"; a generic tool to generate text output (anything from HTML to autogenerated source code) based on templates.
It's a Java package, a class library for Java programmers.
It's not an application for end-users in itself, but something that programmers can embed into their products.
http://freemarker.sourceforge.net/
The software is increasingly delivered over the Internet as a service. Originally called Software as a Service (SaaS), similar software – with a much stronger emphasis on mobile interaction – is now usually referred to as web apps.
The Twelve‑Factor App is a praiseworthy effort by Heroku, a platform as a service (PaaS) provider, to establish general principles for creating useful web apps. However, the original principles are somewhat specific to Heroku’s PaaS platform. They aren’t an exact fit for a microservices architecture.
In implementing the NGINX MRA, we’ve extended the Twelve‑Factor App with our own additions and microservices‑specific modifications.
Our principles adapt the core ideas in The Twelve‑Factor App to a general‑purposemicroservices architecture that is optimized for continuous delivery.
The Twelve Factors Applied to Microservices
1 – Codebase
One codebase per service, tracked in revision control; many deploys
The Twelve‑Factor App recommends one codebase per app. In a microservices architecture, the correct approach is actually one codebase per service.
2 – Dependencies
Explicitly declare and isolate dependencies
As suggested in The Twelve‑Factor App, regardless of what platform your application is running on, use the dependency manager included with your language or framework. How you install operating system or platform dependencies depends on the platform:
In noncontainerized environments, use a configuration management tool (Chef, Puppet, Ansible) to install system dependencies.
In a containerized environment, do this in the Dockerfile
3 – Config
Store configuration in the environment
Anything that varies between deployments can be consideredconfiguration.
The Twelve‑Factor App guidelines recommend storing all configuration in the environment, rather than committing it to the repository.
We recommend the following specific practices:
Use non‑version controlled .env files for local development. Docker supports the loading of these files at runtime.
Keep all .env files in a secure storage system, such as Vault, to keep the files available to the development teams, but not commited to Git.
Use an environment variable for anything that can change at runtime, and for any secrets that should not be committed to the shared repository.
Once you have deployed your application to a delivery platform, use the delivery platform’s mechanism for managing environment variables.
4 – Backing Services
Treat backing services as attached resources
The Twelve‑Factor App guidelines define a backing service as “any service the app consumes over the network as part of its normal operation.” The implication for microservices is that anything external to a service is treated as an attached resource, including other services. This ensures that every service is completely portable and loosely coupled to the other resources in the system
5 – Build, Release, Run
Strictly separate build and run stages
we recommend the use of a continuous integration/continuous delivery (CI/CD) tool to automate builds. Docker images make it easy to separate the build and run stages. Ideally, images are created from every commit and treated as deployment artifacts.
6 – Processes
Execute the app in one or more stateless processes
For microservices, the important point in the Processes factor is that your application needs to be stateless. This makes it easy to scale a service horizontally by simply adding more instances of that service. Store any stateful data, or data that needs to be shared between instances, in a backing service.
7 – Data Isolation
Each service manages its own data
As a modification to make the Port binding factor more useful for microservices, we recommend that you allow access to the persistent data owned by a service only via the service’s API. This prevents implicit service contracts between microservices and ensures that microservices can’t become tightly coupled. Data isolation also allows the developer to choose, for each service, the type of data store that best suits its needs.
8 – Concurrency
Scale-out via the process model
The Unix process model is largely a predecessor to a true microservices architecture, insofar as it allows specialization and resource sharing for different tasks within a monolithic application. In a microservices architecture, you can horizontally scale each service independently, to the extent supported by the underlying infrastructure. With containerized services, you further get the concurrency recommended in the Twelve‑Factor App, for free.
9 – Disposability
Maximize robustness with fast startup and graceful shutdown
Instances of a service need to be disposable so they can be started, stopped, and redeployed quickly, and with no loss of data. Services deployed in Docker containers satisfy this requirement automatically, as it’s an inherent feature of containers that they can be stopped and started instantly. Storing state or session data in queues or other backing services ensures that a request is handled seamlessly in the event of a container crash
10 – Dev/Prod Parity
Keep development, staging, and production as similar as possible
Keep all of your environments – development, staging, production, and so on – as identical as possible, to reduce the risk that bugs show up only in some environments. To support this principle, we recommend, again, the use of containers – a very powerful tool here, as they enable you to run exactly the same execution environment all the way from local development through production
11 – Logs
Treat logs as event streams
Instead of including code in a microservice for routing or storing logs, use one of the many good log‑management solutions
12 – Admin Processes
Run admin and management tasks as one‑off processes
In a production environment, run administrative and maintenance tasks separately from the app. Containers make this very easy, as you can spin up a container just to run a task and then shut it down.
In the modern era, software is commonly delivered as a service: called web apps, or software-as-a-service. The twelve-factor app is a methodology for building software-as-a-service apps that:
Use declarative formats for setup automation, to minimize time and cost for new developers joining the project; Have a clean contract with the underlying operating system, offering maximum portability between execution environments; Are suitable for deployment on modern cloud platforms, obviating the need for servers and systems administration; Minimize divergence between development and production, enabling continuous deployment for maximum agility; And can scale up without significant changes to tooling, architecture, or development practices. The twelve-factor methodology can be applied to apps written in any programming language, and which use any combination of backing services (database, queue, memory cache, etc) https://12factor.net/
The Twelve-Factor App methodology is a methodology for building software as a service application. These best practices are designed to enable applications to be built with portability and resilience when deployed to the web
How to build 12-factor microservices applications on AWS with Containers
Microservices is an approach to application development in which a large application is built as a suite of modular services.
To get the benefits of containers andmicroservices, look to a methodology known as the 12-factor app, a popular methodology for building “software-as-a-service apps.
The Unix process model is a simple and powerful abstraction for running server-side programs. It provides a helpful way to think about dividing a web app’s workloads and scaling it up over time.
a simple illustration of the basics of the process model, using a well-known Unix daemon: memcached.
Running a process manually in a terminal is fine for local development, but in a production deployment, your app’s processes should be managed. Managed processes should run automatically when the operating system starts up and should be restarted if the system fails for any reason.
In traditional server-based deployments, the operating system provides a process manager. On macOS, launchd is the built-in process manager; on Ubuntu, systemd is the built-in process manager.
A server daemon like memcached has a single entry point, meaning there’s only one command you run to invoke it.
Web apps, on the other hand, typically have two or more entry points. Each of these entry points can be called a process type.
Process types differ for each app.
A process type is a prototype from which one or more dynos are instantiated. This is similar to the way a class is a prototype from which one or more objects are instantiated in object-oriented programming.
In software development, a codebase (or code base) refers to a whole collection of source code that is used to build a particular software system, application, or software component. Typically, a codebase includes only human-written source code files; thus, a codebaseusually does not include source code files generated by tools (generated files) or binary library files (object files), as they can be built from the human-written source code.
https://en.wikipedia.org/wiki/Codebase
Microservices
In short, themicroservice architectural style [1] is an approach to developing a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms, often an HTTP resource API. These services are built around business capabilities and independently deployable by fully automated deployment machinery. There is a bare minimum of centralized management of these services, which may be written in different programming languages and use different data storage technologies.
http://martinfowler.com/articles/microservices.html
Microservices - also known as the microservice architecture - is an architectural style that structures an application as a collection of loosely coupled services, which implement business capabilities. The microservice architecture enables the continuous delivery/deployment of large, complex applications. It also enables an organization to evolve its technology stack.
https://microservices.io/
what is the difference between APIs and microservices?
The word “microservice” refers to the individual services in a microservice architecture. Microservices are an example of Service-Oriented Architecture, or SOA, which has grown to be a popular alternative to the traditional approach of building singular, self-sufficient applications, which we call monoliths
What Is an API?
API stands for Application Programming Interface, where the keyword is interface. APIs are the doorways, so to speak, that allow developers to interact with an application.
https://nordicapis.com/what-is-the-difference-between-apis-and-microservices/
RESTful API vs Microservice
Microservices is more about architectural whereas RESTful API focuses more on how to expose Microservices.Microservices is more about architectural and design style, and you may be able to implement a Microservices without RESTful API. However, RESTful API makes it easy to build a loosely coupled Microservices.
https://medium.com/@ericjwhuang/restful-api-vs-microservice-eea903ac3e73
API vs. Microservices: A Microservice Is More Than Just an API
APIs are usually developed using a RESTful style. These APIs will have a series of verbs associating with HTTP actions, like the following:
GET (get a single item or a collection)
POST (add an item to a collection)
PUT (edit an item that already exists in a collection)
DELETE (delete an item in a collection)
What Is a Microservice?
Wikipedia defines a microservice as: a software development technique—a variant of the service-oriented architecture (SOA) architectural style that structures an application as a collection of loosely coupled services. In a microservices architecture, services are fine-grained and the protocols are lightweight.
The Difference Between APIs and Microservices
An API is a contract that provides guidance for a consumer to use the underlying service.
A microservice is an architectural design that separates portions of a (usually monolithic) application into small, self-containing services.
https://www.scalyr.com/blog/api-vs-microservices
The Difference Between Microservices and Web Services
your software can use both microservices and web services at the same time.
https://dzone.com/articles/the-difference-between-microservices-and-web-servi
The Difference between Web Services and Micro Services
Micro Services and Web Services are two different concepts of Application Development Architecture, which can be differentiated from its layered architecture and development style
What is Web Service?
Web Service is a way to expose the functionality of an application to other application, without a user interface. It is a service which exposes an API over HTTP.Web Service is a connection technology, a way to connect services together into a Service Oriented Architecture (SOA).
What is Micro Service?
Micro Service is independently deployable service modeled around a business domain. It is a method of breaking large software applications into loosely coupled modules, in which each service runs a unique process and communicates through APIs. It can be developed using messaging or event-driven APIs, or using non-HTTP backed RPC mechanisms.
https://www.tatvasoft.com/blog/the-difference-between-micro-services-and-web-services/
Microservices are an architectural and organizational approach to software development where software is composed of small independent services that communicate over well-defined APIs.
Microservices architectures make applications easier to scale and faster to develop, enabling innovation and accelerating time-to-market for new features.
Characteristics of Microservices
Autonomous
Each component service in a microservices architecture can be developed, deployed, operated, and scaled without affecting the functioning of other services. Services do not need to share any of their code or implementation with other services. Any communication between individual components happens via well-defined APIs.
Specialized Each service is designed for a set of capabilities and focuses on solving a specific problem. If developers contribute more code to a service over time and the service becomes complex, it can be broken into smaller services.
Microservices are an architectural and organizational approach to software development where software is composed of small independent services that communicate over well-defined APIs.
Monolithic vs. Microservices Architecture
With monolithic architectures, all processes are tightly coupled and run as a single service. This means that if one process of the application experiences a spike in demand, the entire architecture must be scaled
Monolithic architectures add risk for application availability because many dependent and tightly coupled processes increase the impact of a single process failure.
With a microservices architecture, an application is built as independent components that run each application process as a service.
These services communicate via a well-defined interface using lightweight APIs.
Containers
Amazon Elastic Container Service
A highly scalable, high-performance container management service that supports Docker containers and allows you to easily run applications on a managed cluster of Amazon EC2 instances.
Serverless
AWS Lambda
AWS Lambda lets you run code without provisioning or managing servers. Just upload your code and Lambda manages everything that is required to run and scale your code with high availability
https://aws.amazon.com/microservices/
AWS Case Study: Coursera Moves to a Microservices-Based Architecture
The Challenge
Coursera had a large monolithic application for processing batch jobs that was difficult to run, deploy, and scale.
A new thread was created whenever a new job needed to be completed, and each job took up different amounts of memory and CPU, continually creating inefficiencies.
A lack of resource isolation allowed memory-limit errors to bring down the entire application.
The infrastructure engineering team attempted to move to a microservices architecture using Docker containers, but they ran into problems as they tried to use Apache Mesos to manage the cluster and containers—Mesos was complicated to set up and Coursera didn’t have the expertise or time required to manage a Mesos cluster.
The Solution
Docker containers on Amazon EC2 Container Service (ECS) enabled Coursera to easily move to a microservices -based architecture.
Each job is created as a container and Amazon ECS schedules the container across the Amazon EC2 instance cluster.
Amazon ECS handles all the cluster management and container orchestration, and containers provide the necessary resource isolation.
The Benefits
Ease of use: Because Amazon ECS setup is straightforward and it manages all of the details of the cluster, the team had a prototype up and running in under two months.
Speed and agility: Time to deploy software changes went from hours to minutes, and each team can now develop and update its respective applications independently because the applications are resource isolated with no cross-dependencies.
Scalable capacity: Auto Scaling groups allow the compute capacity to scale up to handle dynamic job loads.
Operational efficiency: No extra infrastructure engineering time is spent installing software and maintaining a cluster—Amazon ECS handles everything from cluster management to container orchestration.
Supports pipeline with billions of data points uploaded every day from different mobile applications running Localytics analytics software.
Engineering team needed to access subsets of data for creating new services, but this led to additional capacity planning, utilization monitoring, and infrastructure management.
Platform team wanted to enable self-service for engineering teams.
The Solution
Uses AWS to send about 100 billion data points monthly through Elastic Load Balancing to Amazon Simple Queue Service, then to Amazon Elastic Compute Cloud, and finally into an Amazon Kinesis stream.
For each new feature of the marketing software, a new microservice using AWS Lambda is created to access the Amazon Kinesis data stream. Each microservice can access the data stream in parallel with others.
The Benefits
Decouples product engineering efforts from the platform analytics pipeline, enabling the creation of new microservicesto access data stream without the need to be bundled with the main analytics application.
Eliminates the need to provision and manage infrastructure to run each microservice.
Lambda automatically scales up and down with load, processing tens of billions of data points monthly.
Speeds time to market for new customer services, since each feature is a new microservice that can run and scale independently of every other microservice.
stands for Service Oriented Architecture -- refers to architectures designed with a focus on services
Web services
This accounts for the subset of SOA using web-related technologies. This typically involves HTTP and XML but it could also use FTP
REST(ful)
REST is a subset of web services -- and hence a SOA-- that revolves around using HTTP for communication Microservices
promotes implementing applications as a set of simple independently deployable services.
https://stackoverflow.com/questions/27054162/what-are-rest-restful-soa-and-microservices-in-simple-terms
What is Web Service?
Web Service is a way to expose the functionality of an application to other application, without a user interface. It is a service which exposes an API over HTTP.
Web Service is a connection technology, a way to connect services together into a Service Oriented Architecture (SOA).
What is Micro Service?
Micro Service is independently deployable service modeled around a business domain. It is a method of breaking large software applications into loosely coupled modules, in which each service runs a unique process and communicates through APIs. It can be developed using messaging or event-driven APIs, or using non-HTTP backed RPC mechanisms. Micro Services are designed to cope with failure and breakdowns of large applications. Since multiple unique services are communicating together, it may happen that a particular service fails, but the overall larger applications remain unaffected by the failure of a single module.
https://www.tatvasoft.com/blog/the-difference-between-micro-services-and-web-services/
Coarse-grained vs fine-grained
Granularity is the extent to which a system is broken down into small parts, either the system itself or its description or observation.
It is the extent to which a larger entity is subdivided.
For example, a yard broken into inches has finer granularity than a yard broken into feet.
1 Yard = 3 Feet=36 inches
Coarse-grained systems consist of fewer, larger components than fine-grained systems
Coarse-grained systems consist of fewer, larger components than fine-grained systems; a coarse-grained description of a system regards large subcomponents while a fine-grained description regards smaller components of which the larger ones are composed.
http://en.wikipedia.org/wiki/Granularity
An Introduction to Service-Oriented Architecture
SOA: approach to distributed software architecture(DSA) employing loosely coupled services
semantic web; web data which can be directly or indirectly processed by machines
cloud computing: internet computing which allows users on-demand access to distributed services(on-demand means payable when requested or presented)
Enterprise Service Bus(ESB) is SOA implementation.
With ESB you can't make changes easily
what is service-oriented architecture SOA?
easy to assemble
easily reconfigurable
modularity, assemble the way you want by adding new blocks or old block or some else's blocks
make change easier
What is Service Oriented Architecture? SOA Introduction or Fundamentals
SOA is an architecture which defines links and integrates re-usable business services
Oracle SOA Suite 11g, is an integrated, best-of-breed suite of products that helps you rapidly design and assemble, deploy and manage, highly agile and adaptable business applications.
Java/J2EE interview questions:- What is Webservice?
To ensure interoperability, web service uses XML
Webservice is operating-system and programming language independent.
Webservice structure is divided into two parts: a service provider and service consumer
How does Webservice communicate? Service provider and service consumer communicates over SOAP protocol
UDDI is a directory service. To search available web services, UDDI is used.UDDI stores web service interfaces.
WSDL is used to locating and describing web service
WS-Security
WS-Security (Web Services Security, short WSS) is a flexible and feature-rich extension to SOAP to apply security to web services
http://en.wikipedia.org/wiki/WS-Security
Universal Description, Discovery, and Integration (UDDI) is a directory service where businesses can register and search for Web services.
UDDI is a platform-independent framework for describing services, discovering businesses, and integrating business services by using the Internet.
UDDI stands for Universal Description, Discovery, and Integration
UDDI is a directory for storing information about web services
UDDI is a directory of web service interfaces described by WSDL
UDDI communicates via SOAP UDDI is built into the Microsoft .NET platform
http://www.w3schools.com/wsdl/wsdl_uddi.asp In simple terms, a Web Service is an application or business logic that is accessible using standard Internet protocols.
Web Service(WS) vs Remote Method Invocation(RMI) vs CORBA
1-Development
In fact the development processes are now very similar for all technologies.
One starts with an interface – such as IDL.
One generates a client stub and a base class for a server implementation.
There are slight differences in how the client stubs get generated – see rmi.
With WS, one actually has a choice –
define the WSDL and work down start with a programmatic interface and generate WSDL and thence the client.
2-Coding
So there are no really differences in development costs, and other factors will determine which technology is picked.
Very similar for WS (JAXRPC), Java-RMI, CORBA (at least for stateless singleton server)
Client Obtains proxy stub for remote service
~6 lines of code, differing for implementation
Invokes operations via stub
Server
Implementation class
Instantiated in some “container” Servlet engine, RMI-process, CORBA/POA framework
3-Tradeoffs
Interoperability is important for internet services where client organizations may choose a different technology. Here, one might expect to choose web services
But what about in house intranet applications – could WS really compete with distributed objects.
Development mechanism, and code complexity essentially the same for all
Expected Tradeoffs
Supposed higher performance for RMI/CORBA
Greater interoperability for WebService
The use of distributed computing technologies for problem-solving has been around for many years. The early paradigm of distributed computing has been that of remote procedure calls (RPC).
However, in recent years, this paradigm has shifted to the use of remote objects due to the acceptance of object-oriented programming practices.
Even today web services are built around the concept of messaging and frequently these messages take the form of request/response-type remote procedure calls on remote objects.
This paper focuses on three specific middleware standards for distributed computing, namely:
the Common Object Request Broker Architecture (CORBA),
Java’s Remote Method Invocation (RMI),
the more recent web services technology, frequently based on XML data encoding and SOAP -based messaging protocols.
The three middleware standards we have selected all have certain commonalities. All are based on the concept of a client application using the services available on a remote machine, or server.
A remote executable object that implements one or more exposed interfaces provides these services.
The object’s interface represents a contract between the client and the server. This interface is written as a Java interface for Java RMI, in IDL for CORBA, and in WSDL for web services.
In the latter two cases, the more generic descriptions can be translated into specific language implementations, although a standard
translation of WSDL into a wide variety of languages is still being developed.
All three technologies also contain the notion that a client application need not know the exact network
location of an object prior to runtime.
A ‘discovery’ process exists (with varying levels of sophistication) to enable the client to obtain a handle to an object that implements a particular desired interface.
This discovery takes the form of a Naming Registry or Service in Java RMI and CORBA, and WSDL repositories or UDDI in Web Services.
Due to Java’s inherent platform-independent capabilities, RMI-based applications are capable of running on a wide variety of computing platforms.
This represents both a strength and weakness of Java RMI, however.
The weakness is due to RMI’s the heavy reliance on Java and lack of direct support for other common languages, such as C or C++.
CORBA chose a new interface description language, known as the IDL, for defining its object interfaces. This intermediate language can then be used to translate to/from a variety of different languages, such as C, C++, and Java.
This makes CORBA more suited toward integration with legacy systems written in languages created before Java, in that it is
language agnostic.
The exact definition of a web service can be viewed as a collection of methods (with hidden implementations) that can be discovered and invoked by a client application.
The network wire protocols used in Web Services are typically XML-based and ride on a network protocol such as HTTP, HTTPS, SMTP, et al.
A protocol known as SOAP is currently in use for describing the messages sent to/from web services and is itself an application of XML.
Web services are language agnostic, much like CORBA, in that the interfaces are described in WSDL, which, like IDL, is independent of any one particular
computing language.
Between EJB and web services, web services would give you more portability if you want to be able to call them from non-java apps in the future. EJB again gives you things like transaction management and pooling that you might not get "out of the box" with web services
If you need the ability to call the objects from a non-java app, you can always front your EJBs with simple web service proxies as needed.
Web services are great in theory, but there are some gotchas that you need to watch out for:
Latency. Fowler's first law of distributed objects: "Don't!" An architecture consisting of lots of fine-grained distributed SOAP services will be elegant, beautiful, and slow as molasses. Think carefully before distributing.
Marshaling from XML to objects and back consumes CPU cycles that aren't providing any business value besides allowing your clients to speak a platform-agnostic protocol.
SOAP is a standard that is becoming more bloated and complex every day, but it has lots of tool support. Vendors like it because it helps drive sales of ESBs. REST is simple but not as well understood. It's not supported by tools.
If your backend servers are not going to be exposed publicly, then you are not getting any benefit from using platform independent web service interfaces such as SOAP/REST.
the web services do allow a loosely coupled architecture.
With RMI, you have to make sure that the objects stay in sync in all applications, which means that you always have to deploy both of them at the same time even if only one of them is changed(not necessarily, but it is requiredquite often because of serial UUIDs
In distributed computing, distributed objects are objects (in the sense of object-oriented programming) that are distributed across different address spaces, either in different processes on the same computer, or even in multiple computers connected via a network, but which work together by sharing data and invoking methods.
Examples
The RPC facilities of the cross-platform serialization protocol, Cap'n Proto amount to a distributed object protocol. Distributed object method calls can be executed(chained, in a single network request, if needs be) through interface references/capabilities
Distributed objects are implemented in Objective-C using the Cocoa API with the NSConnection class and supporting objects. Distributed objects are used in Java RMI.
CORBA lets one build distributed mixed object systems.
DCOM is a framework for distributed objects on the Microsoft platform. DDObjects is a framework for distributed objects using Borland Delphi. Jt is a framework for distributed components using a messaging paradigm. JavaSpaces is a Sun specification for a distributed, shared memory (space-based)
Pyro is a framework for distributed objects using the Python programming language.
Distributed Ruby (DRb) is a framework for distributed objects using the Ruby programming language.
https://en.wikipedia.org/wiki/Distributed_object
Apache CXF™ is an open source services framework. CXF helps you build and develop services using frontend programming APIs, like JAX-WS and JAX-RS. These services can speak a variety of protocols such as SOAP, XML/HTTP, RESTful HTTP, or CORBA and work over a variety of transports such as HTTP, JMS or JBI.
http://cxf.apache.org/
Introduction to Web Services
Web service is an implementation of services oriented architecture(SOA)
Web services and its benefits
a standardized way of integrating web applications
XML based message communication
hardware platform independent
programming language independent
operating system independent
web service server(provider) code and web service client(consumer) code can be written in any programming language like PHP java c# etc
service provider publishes web service in WSDL into UDDI. service consumer issues a request into UDDI to locate web service WSDL.
Benefits:1-application and data integration 2-code re-use 3-cost savings
web services are deployed on j2ee containers
What is SOAP?
SOAP, originally defined as Simple Object Access Protocol, is a protocol specification for exchanging structured information in the implementation of Web Services in computer networks.
It relies on Extensible Markup Language (XML) for its message format, and usually relies on other Application Layer protocols, most notably Hypertext Transfer Protocol (HTTP) and Simple Mail Transfer Protocol (SMTP), for message negotiation and transmission
SOAP also has some advantages:
Easy to consume - sometimes
Rigid - type checking, adheres to a contract
Development tools
The acronym REST stands for Representational State Transfer, this basically means that each unique URL is a representation of some object.
You can get the contents of that object using an HTTP GET, to delete it, you then might use a POST, PUT, or DELETE to modify the object (in practice most of the services use a POST for this).
Representational state transfer (REST) is a style of software architecture for distributed hypermedia systems such as the World Wide Web.
RESTful web services
A RESTful web service (also called a RESTful web API) is a simple web service implemented using HTTP and the principles of REST.
It is a collection of resources, with four defined aspects:
the base URI for the web service, such as http://example.com/resources/
the Internet media type of the data supported by the web service. This is often JSON, XML or YAML but can be any other valid Internet media type.
the set of operations supported by the web service using HTTP methods (e.g., GET, PUT, POST, or DELETE).
The API must be hypertext driven.
the main advantages of REST web services are
Lightweight - not a lot of extra xml markup
Human Readable Results
Easy to build - no toolkits required
What is REST ( Representational state transfer ) ?
Web fundamentals that REST uses
1-http protocol
2-http protocol has methods like get/post/delete
3-http protocol is stateless
4-URI,by which you can locate any source on the web
all web resources are shown by URIs
SOAP vs REST
Compared to SOAP, REST is a lighter-weight and less feature-rich approach to building web services.
As such, it does not support the infrastructure built on top of SOAP (like WSDL, UDDI, and WS-Security).
JAX-WS supports a limited kind of REST API.
RESTEasy
RESTEasy is a JBoss project that provides various frameworks to help you build RESTful Web Services and RESTful Java applications. It is a fully certified and portable implementation of the JAX-RS specification. JAX-RS is a new JCP specification that provides a Java API for RESTful Web Services over the HTTP protocol.
http://www.jboss.org/resteasy
SOAP and REST are two API styles that approach the question of data transmission from a different point of view.
What does REST stand for?
REST stands for Representational State Transfer. It’s an architectural style that defines a set of recommendations for designing loosely coupled applications that use the HTTP protocol for data transmission. REST doesn’t prescribe how to implement the principles at a lower level. Instead, the REST guidelines allow developers to implement the details according to their own needs. Web services built following the REST architectural style are called RESTful web services.
What’s the main reason to use REST?
In 2018, REST was the most popular choice of developers to build public APIs. You can find many examples all over the internet, especially since all big social media sites provide REST APIs so that developers can seamlessly integrate their apps with the platform.
REST and JSON
The REST architecture allows API providers to deliver data in multiple formats such as plain text, HTML, XML, YAML, and JSON, which is one of its most loved features.
JSON stands for JavaScript Object Notation. It’s an easy-to-parse and lightweight data-interchange format. In spite of its name, JSON is completely language-agnostic, so it can be used with any programming language, not just JavaScript
https://raygun.com/blog/soap-vs-rest-vs-json/
SOAP vs REST
REST:
exposes RESOURCES which represent DATA
point-to-point communication over HTTP
supports multiple data formats(not just xml)
emphasizes stateless communication
uses HTTP GET/POST/DELETE
SOAP:
exposes OPERATIONS which represent LOGIC
loosely coupled distributed messaging
supports only XML
stateful and stateless/conversational communication
strong typing
supports asynchronous messaging
uses HTTP post
REST IS BETTER THAN SOAP
can be consumed by a web browser with javascript or ajax
lightweight(doesnot require xml parsing and SOAP header for every message thus requires less bandwidht)
SOAP IS BETTER THAN REST
rest only supports http/https thus there's no asynchronous messaging. Because HTTP is synchronous communication.
rest is not secure as parameters are part of URI
rest can't be governed as there is not service registry thus you have no idea who's consuming services
rest and soap can co-exist
REST GOOD FOR
webservices
exposing data over internet
limited bandwitdh(small sized data) and resources(no xml parsing)
combining content from many different sources on a web browser
SOAP GOOD FOR
enterprise services
asynchronous messaging
stateful/conversational operations
What are the differences between JAX-RPC, JAX-WS, JAX-RS, Apache Axis, SAAJ, Apache SOAP, JWSDP, Metro, Jersey, and GlassFish?
JAX-RPC is a specification/API for Java developers to develop SOAP based interoperable web services. This API is now obsolete and may be dropped from the next JEEversion. JAX-WS is the successor to JAX-RPC. It requires Java 5.0, and is not backward-compatible to JAX-RPC.
SAAJ is another specification/API for using SOAP envelopes with or without attachments. It operates on a lower level than JAX-RPC or JAX-WS, both of which will useSOAP envelopes based on SAAJ if needed. Apache Axis is an open source implementation of the Java WS APIs for sending and receiving SOAP messages. Axis 1 supports JAX-RPC and SAAJ, while Axis 2 supports SAAJ and JAX-WS. Apache SOAP was the first SOAP implementation. It is now obsolete. It's better to use Apache Axis to avail oneself of the latest features.
Sun JWSDP - Sun Java Webservices Developer Pack, is an implementation of JAX-RPC, SAAJ, and various other XML Java technologies. It is now deprecated in favor of the Metro stack. GlassFish is the open source reference implementation of J2EE 5. As such, it contains an implementation of JAX-WS.
Metro is the web services stack used in GlassFish. It supports SAAJ, JAX-WS, WS-Security and other standards.
JAX-RS is a Java API for RESTful web services.
Jersey is the reference implementation of the JAX-RS API, as defined in the JSR-311 standard for RESTful web services.
The WebSocket specification—developed as part of the HTML5 initiative—introduced the WebSocket JavaScript interface, which defines a full-duplex single socket connection over which messages can be sent between client and server.
The WebSocket standard simplifies much of the complexity around bi-directional web communication and connection management.
http://www.websocket.org/
Web Sockets
Web Sockets is a next-generation bidirectional communication technology for web applications which operates over a single socket and is exposed via a JavaScript interface in HTML 5 compliant browsers.
Once you get a Web Socket connection with the web server, you can send data from browser to server by calling a send() method, and receive data from server to browser by an onmessage event handler.
http://www.tutorialspoint.com/html5/html5_websocket.htm
WebSockets (using Socket.io) Tutorial #1 - What Are WebSockets?
What are WebSockets | How is it different from HTTP?
Difference between WebSocket vs REST
WebSocket is a communication protocol over a TCP connection, which provides point-to-point communication system
REST i.e. Representational State Transfer, defines a set of constraints to be utilized for creating web services. It is one of the architectural styles, to create REST endpoints using HTTP in a web application. RESTful endpoints are being called, which would invoke APIs that too are RESTful in nature and giving an HTTP response. A request would originate from the client with the HTTP verbs i.e. Get, Post, Put, Delete. They react to the expected set of operations, receive the data, update the data or can delete the data depending upon the verb.
Operations with REST are standard, and stateless in nature, which actually makes any system which is RESTful, fast performer, reliable and at the same time, his ability to grow. REST can be cited as one of the standard ways of designing the APIs for the request.
https://www.educba.com/websocket-vs-rest/
REST api vs REST Webservice vs RESTFul web service
REST API = RESTful API
REST Web service = RESTful Web service
A RESTful web service is the implementation of the REST API (Application Programmable Interface) or the REST spec.
https://stackoverflow.com/questions/33796975/rest-api-vs-rest-webservice-vs-restful-web-service
Difference Between API and Web Service
API and Web service serve as a means of communication. The only difference is that a Web service facilitates interaction between two machines over a network. An API acts as an interface between two different applications so that they can communicate with each other
https://medium.com/@programmerasi/difference-between-api-and-web-service-73c873573c9d
