General Programming

Example of using the role attribute, which defines the purpose of an element, such as a button, along with id and area-labelledby properties

(See image)

What are the seven layers of the OSI model, in descending order of how they are built on one another?

- Application Layer - Presentation Layer - Session Layer - Transport Layer - Network Layer - Data link layer - Physical layer

How to pronounce "nodemon"?

/nohd' mahn/

What are the two kinds of projection done with wireframe rendering?

1. Orthographic projection -- lines are not done with natural perspective; for example, a cube will have parallel lines to go along with the parallel lines of a side of the cube 2. Perspective projection -- parallel lines converge as they get farther from the viewer

What is the hierarchy of domains starting with top-level domains?

1. Top level, ex. .com, .edu, etc. 2. Second level, ex. google in google.com 3. Subdomain, ex. food in food.cooking.com

What is a BOM?

A byte order mark (BOM) consists of the character code U+FEFF at the beginning of a data stream, where it can be used as a signature defining the byte order and encoding form, primarily of unmarked plaintext files. Under some higher level protocols, use of a BOM may be mandatory (or prohibited) in the Unicode data stream defined in that protocol.

What's a breaking change?

A change in one part of a software system that potentially causes other components to fail; occurs most often in shared libraries of code used by multiple applications. Not possible to fix old entries without a breaking change, so remap old to new in import lib.

What is a LAN?

A network that connects computers within a limited area such as a school or office

What's an assembler?

A program that converts human readable instructions into machine code

What is lexical structure?

A programming language's lexical structure specifies set of some basic rules about how a code should be written in it. Rules like what variable names looks like, the delimiter characters for comments, and how one program statement is separated from the next. It is the lowest-level syntax of a language.

What is TCP?

A reliable transmission system that sends and tracks binary sequences of data that are split into small packets sent separately; its header is inside the data payload of the data package, separate from but combined with the IP header

What is the nodemon module?

A tool that helps develop node. js based applications by automatically restarting the node application when file changes in the directory are detected. nodemon does not require any additional changes to your code or method of development.

What's a wireframe rendering?

A visual transformation from 3d to 2d, where drawn lines make 2d look like 3d

What does the back and forth between packets being sent and acknowledgements being sent and the rate of ACK success allow TCP to do?

Adjust the level of aggressiveness of packet transfer to provide congestion control

What two things must a website have?

An IP address and a port

What is the difference between IP and UDP?

An IP gets the packet of data to the right computer but a UDP gets the packet to the right program running on that computer An IP -- is very low-level -- only has an address in its packet header -- it knows which computer to send information to but it doesn't know which application to send it to A UDP -- has its own header, inside the data payload -- has a header that contains information such as a port number and checksum -- the port number in its header determines where the data is sent

What is an IP?

An addressing system that finds paths to distant computers

What is an embedded database system?

An embedded database system is a database management system (DBMS) which is tightly integrated with an application software that requires access to stored data, such that the database system is "hidden" from the application's end-user and requires little or no ongoing maintenance. It is actually a broad technology category that includes database systems with differing application programming interfaces (SQL as well as proprietary, native APIs), database architectures (client-server and in-process), storage modes (on-disk, in-memory, and combined), database models (relational, object-oriented, entity-attribute-value model, network/CODASYL), and target markets. The term embedded database can be confusing because only a small subset of embedded database products are used in real-time embedded systems such as telecommunications switches and consumer electronics devices.[1] (See mobile database for small-footprint databases that could be used on embedded devices.)

What is a runtime environment?

As soon as a software program is executed, it is in a runtime state. In this state, the program can send instructions to the computer's processor and access the computer's memory (RAM) and other system resources. When software developers write programs, they need to test them in the runtime environment. Therefore, software development programs often include an RTE component that allows the programmer to test the program while it is running. This allows the program to be run in an environment where the programmer can track the instructions being processed by the program and debug any errors that may arise. If the program crashes, the RTE software keeps running and may provide important information about why the program crashed. When you see the name of a software program with the initials "RTE" after it, it usually means the software includes a runtime environment. While developers use RTE software to build programs, RTE programs are available to everyday computer users as well. Software such as Adobe Flash Player and Microsoft PowerPoint Viewer allow Flash movies and PowerPoint presentations to be run within the player software. These programs provide a runtime environment for their respective file formats. The most common type of RTE, however, is the Java RTE (or JRE), which allows Java applets and applications to be run on any computer with JRE installed. 7 There are a few components that make up the runtime environment. Not all components are applicable to all environments (e.g. assembler, C++, and C# all have different runtime facilities), but they generally comprise the following: The CPU and hardware platform on which the program runs. The operating system that runs the program, including device drivers that interface with the hardware. Standard libraries available to the language and platform. Certain environments (e.g. embedded) may pare down the relevant standard library due to space concerns. Frameworks and other libraries linked into the program either statically or dynamically. Any interpreter that sits between the program and the operating system, such as the CLR, JVM, shell (for e.g. a Bash script), Perl/Python interpreter, et al. Remember, computers are all about layers and abstractions. As you can gather from the list above, a runtime is pretty much a collection of abstractions that sit between the bare metal and the running program. The Runtime Envionment is a somewhat nebulous term which collectively refers to the virtual machine in which your code runs, and the standard libraries and services that your code may expect to find available to it. It can also be thought of as a layer of isolation between your code and the underlying operating system, so that your code can be agnostic of it, and therefore portable. The long answer: In the (not so good) old days when FORTRAN and COBOL ruled, the language was also the Runtime Environment. Most applications were built using whatever features the language provided, and that was enough. As a result, the syntax of the languages was very complex, and still the stuff that you could do with them were limited to whatever the authors of the language could imagine at the time that they were creating the language: accessing files and databases, reading and writing characters to and from terminals, and that was pretty much it. When C came out, it made a clear distinction between the language and the Runtime Libraries. The C language itself is extremely minimalistic, offering only the bare essentials necessary for expressing program logic, and delegating everything else to be done by libraries. The standard libraries provide commonly used stuff, and you can add external libraries for anything else. For example, the C language has no built-in concept of memory allocation; in order to allocate memory you have to invoke malloc(), a standard library routine. And if malloc() is not good enough for you, then you can use some other library that offers something that better suits your needs. The standard runtime libraries were the precursor of runtime environments, but things were not really there yet, because back in the days of C the Unix operating system was mostly playing the role of the runtime environment, so there was no concept of portability: according to the Unix world, the Unix world was the only world. When the portable, virtual-machine-based languages like Java and C# came out, there was a need to provide an additional layer of isolation between applications and the underlying operating system, so that applications could run either on Unix, or on Windows, or on anything else. That was provided by the virtual machine and the rich set of libraries that it came with. Share Improve this answer Follow edited Apr 3 '20 at 13:24 answered Dec 7 '15 at 1:38 Mike Nakis30.6k66 gold badges6868 silver badges108108 bronze badges "Back in the days of C ... there was no concept of portability." - Where do you get this idea from? For example, if you read The C Programming Language the authors mention portability a lot. - Brandin Dec 7 '15 at 11:01 @Brandin well, you are right, I could have worded that a bit better. If you read carefully, you will see that when I speak of lack of portability I am talking about Unix, not C. What I mean is that (although C is of course a highly portable language,) the Unix environment itself was not trying to make portability any easier for people trying to develop software back then. It was quite different from anything existing at that time. So, in this sense Unix as a runtime environment did not have the goal of enabling portability, the way the modern concept of a runtime environment does. - Mike Nakis Dec 7 '15 at 11:16 Add a comment 2 what really is the runtime environment in general? Yes, your broad understanding "runtime environment is the environment on which the code will run" is about as specific as that term will be defined. Not just for .NET, but in programming in general, what is the runtime environment? Effectively, the hardware your code is running on. The OS your code is running on. The libraries made available to your code when running. The environment variables that your code has access to. The locale your program is running in. (If applicable) the JIT compiler/byte-code interpreter/garbage collector/sandbox/app server your code is running on. In summary, how should we properly understand the idea of runtime environment? It varies from job to job. Many programs don't care very much at all, because it doesn't really matter. Some programs need to care a great deal, because the platform their running on doesn't do a great job at abstracting away hardware differences, or because the code will vary its behavior depending on the environment it's running in. But as a term, knowing "runtime environment" generally refers to the intermediary "stuff" needed to run managed languages like C# and Java is sufficient

What is a Progressive Web App?

At their heart, Progressive Web Apps are just web applications that are installable. Using progressive enhancement, new capabilities are enabled in modern browsers. Using service workers and a web app manifest, your web application becomes reliable and installable. If the new capabilities aren't available, users still get the core experience. They are platform-specific applications, known for being incredibly rich and reliable. They're ever-present, on home screens, docks, and taskbars. They work regardless of network connection. They launch in their own standalone experience. They can read and write files from the local file system, access hardware connected via USB, serial or bluetooth, and even interact with data stored on your device, like contacts and calendar events. In these applications, you can do things like take pictures, see playing songs listed on the home screen, or control song playback while in another app. Platform-specific applications feel like part of the device they run on. Progressive Web Apps (PWA) are built and enhanced with modern APIs to deliver enhanced capabilities, reliability, and installability while reaching anyone, anywhere, on any device with a single codebase.

What happens because TCP can allow there to be many acknowledgements outstanding at one time?

Bandwidth is increased but no time is wasted waiting for acknowledgements

Why are relative paths preferred?

Because the relationships between files persist between machines, but an absolute path is really only good for the machine it's on. The absolute path shows the directory path all the way back to root.

How are SOA and microservices similar?

Both are different from a traditional, monolithic architecture in that every service will have its own responsibility; both are scalable, agile approaches.

What are some SOA examples?

By 2010, SOA implementations were going full steam at leading companies in virtually every industry. For example: Delaware Electric turned to SOA to integrate systems that previously did not talk to each other, resulting in development efficiencies that helped the organization stay solvent during a five-year, state-mandated freeze on electric rates. Cisco adopted SOA to make sure its product ordering experience was consistent across all products and channels by exposing ordering processes as services that Cisco's divisions, acquisitions, and business partners could incorporate into their websites. Independence Blue Cross (IBC) of Philadelphia implemented an SOA to ensure that the different constituents dealing with patient data—IBC customer service agents, physicians' offices, IBC web site users—were working with the same data source (a 'single source of truth').

What's the difference between pass by value and pass by reference?

By definition, pass by value means you are making a copy in memory of the actual parameter's value that is passed in, a copy of the contents of the actual parameter. Use pass by value when when you are only "using" the parameter for some computation, not changing it for the client program. When a parameter is passed by value, the caller and callee have two independent variables with the same value. If the callee modifies the parameter variable, the effect is not visible to the caller. In pass by reference (also called pass by address), a copy of the address of the actual parameter is stored. Use pass by reference when you are changing the parameter passed in by the client program. When a parameter is passed by reference, the caller and the callee use the same variable for the parameter. If the callee modifies the parameter variable, the effect is visible to the caller's variable.

What was the first computer language that was cross-platform?

COBOL

What search keywords can you use to make sure you are only searching for image, audio, and video resources that aren't subject to copyright?

Creative Commons Licenses

How are DNS servers organized?

Different ones are responsible for different parts of the domain tree

What is a quick rundown of development of programming languages?

Directly writing machine code and punch cards/tape Assembly language Compiled languages: FORTRAN (Formula translator) COBOL (Common Business-oriented Language) 1960s -- ALGOL, LISP, BASIC 1970s -- Pascal, C, Smalltalk 1980s -- C++, Objective-C, and Perl

What does DNS stand for in terms of a server that provides translation from IP addresses into human-readable domain names?

Domain Name Server

What does DNS stand for in terms of a service that provides translation from IP addresses into human-readable domain names?

Domain Name Service

What does the physical layer of the OSI entail?

Electrical signals on wires, and radio signals for wireless communication

What is an ESB?

Enterprise service bus. It is an architectural pattern whereby a centralized software component performs integrations between applications. It performs transformations of data models, handles connectivity/messaging, performs routing, converts communication protocols and potentially manages the composition of multiple requests. The ESB can make these integrations and transformations available as a service interface for reuse by new applications. The ESB pattern is typically implemented using a specially designed integration runtime and toolset that ensures the best possible productivity. It is possible to implement an SOA without an ESB, but this would be equivalent to just having a bunch of services. Each application owner would need to directly connect to any service it needs and perform the necessary data transformations to meet each of the service interfaces. This is a lot of work (even if the interfaces are reusable) and creates a significant maintenance challenges in the future as each connection is point to point. In fact, ESBs were, eventually, considered such a de facto element of any SOA implementation that the two terms are sometimes used as synonyms, creating confusion. What is an ESB? An Enterprise Service Bus (ESB) is fundamentally an architecture. It is a set of rules and principles for integrating numerous applications together over a bus-like infrastructure. ESB products enable users to build this type of architecture, but vary in the way that they do it and the capabilities that they offer. The core concept of the ESB architecture is that you integrate different applications by putting a communication bus between them and then enable each application to talk to the bus. This decouples systems from each other, allowing them to communicate without dependency on or knowledge of other systems on the bus. The concept of ESB was born out of the need to move away from point-to-point integration, which becomes brittle and hard to manage over time. Point-to-point integration results in custom integration code being spread among applications with no central way to monitor or troubleshoot. This is often referred to as "spaghetti code" and does not scale because it creates tight dependencies between applications. Why use an ESB? Increasing organizational agility by reducing time to market for new initiatives is one of the most common reasons that companies implement an ESB as the backbone of their IT infrastructure. An ESB architecture facilitates this by providing a simple, well defined, "pluggable" system that scales really well. Additionally, an ESB provides a way to leverage your existing systems and expose them to new applications using its communication and transformation capabilities. Implementation The ESB architecture has some key principles that allow for business agility and scale. The key focus is to decouple systems from each other while allowing them to communicate in a consistent and manageable way. The "bus" concept decouples applications from each other. This is usually achieved using a messaging server like JMS or AMQP. The data that travels on the bus is a canonical format and is almost always XML. There is an "adapter" between the application and the bus that marshals data between the two parties. The adapter is responsible for talking to the backend application and transforming data from the application format to the bus format. The adapter can also perform a host of other activities such as message routing transaction management, security, monitoring, error handling, etc. ESBs are generally stateless; the state is embedded in the messages passing through the bus. The canonical message format is the contract between systems. The canonical format means that there is one consistent message format traveling on the bus and that every application on the bus can communicate with each other Integration core principles Let's take a look at how an ESB architecture maps to our five core integration principles: Orchestration: Composing several existing fine-grained components into a single higher order composite service. This can be done to achieve appropriate "granularity" of services and promote reuse and manageability of the underlying components. Transformation: Data transformation between canonical data formats and specific data formats required by each ESB connector. An example of this would be transforming between CSV, Cobol copybook or EDI formats to either SOAP/XML or JSON. Canoncial data formats can greatly simplify the transformation requirements associated with a large ESB implementation where there are many consumers and providers, each with their own data formats and definitions. Transportation: Transport protocol negotiation between multiple formats (such as HTTP, JMS, JDBC). Note: Mule treats databases like another "service" by making JDBC just another transport (or endpoint) where data can be accessed. Mediation: Providing multiple interfaces for the purpose of a) supporting multiple versions of a service for backwards compatibility or alternatively, b) to allow for multiple channels to the same underlying component implementation. This second requirement may involve providing multiple interfaces to the same component, one legacy interface (flat file) and one standards compliant (SOAP/XML) interface. Non-functional consistency: For a typical ESB initiative, this can include consistency around the way security and monitoring policies are applied and implemented. Additionally, the goals of scalability and availability can be achieved by using multiple instances of an ESB to provide increased throughput (scalability) and eliminate single-points-of-failure (SPOFs), which is the key objective for highly available systems.

What does EPP stand for in EPP code?

Extensible Provisioning Protocol

What is an EPP code?

Extensible Provisioning Protocol (EPP) domain status codes, also called domain name status codes, indicate the status of a domain name registration. Every domain has at least one status code, but they can also have more than one.

What are some examples of companies that have benefited from building PWAs?

For example, Twitter saw a 65% increase in pages per session, 75% more Tweets, and a 20% decrease in bounce rate, all while reducing the size of their app by over 97%. After switching to a PWA, Nikkei saw 2.3 times more organic traffic, 58% more subscriptions, and 49% more daily active users. Hulu replaced their platform-specific desktop experience with a Progressive Web App and saw a 27% increase in return visits.

What does GIF stand for?

Graphical Interchange Format

What is TLS?

HTTPS uses an encryption protocol known as Transport Layer Security (TLS)to encrypt communications.

What is the IEEE?

IEEE is the world's largest technical professional organization dedicated to advancing technology for the benefit of humanity. IEEE and its members inspire a global community through its highly cited publications, conferences, technology standards, and professional and educational activities.

Why are side effects bad?

If you have them, a function can be unpredictable depending on the state of the system

What are the required criteria for a progressive web app in Chrome?

In Chrome, your Progressive Web App must meet the following criteria before it will fire the beforeinstallprompt event and show the in-browser install promotion: The web app is not already installed Meets a user engagement heuristic Be served over HTTPS Includes a Web App Manifest that includes:short_name or nameicons - must include a 192px and a 512px iconstart_urldisplay - must be one of fullscreen, standalone, or minimal-uiprefer_related_applications must not be present, or be false Registers a service worker with a fetch handler

How does DNS represent domain names so that so many domain names can be accommodated?

In a tree-like structure

What is OOD and what is it about?

In object-oriented system design and development, OOD helps in designing the system architecture or layout - usually after completion of an object-oriented analysis (OOA). The designed system is later created or programmed using object-oriented based techniques and/or an object-oriented programming language (OOPL). The OOD process takes the conceptual systems model, use cases, system relational model, user interface (UI) and other analysis data as input from the OOA phase. This is used in OOD to identify, define and design systems classes and objects, as well as their relationship, interface and implementation.

What does TCP allow that UDP, a very simple protocol, doesn't allow?

Information that must be transferred as a unit, without any information missing, such as an email, due to possible service interruptions

What does IP stand for?

Internet Protocol

What does nodemon do?

It constantly refreshes our browser as changes are made

What is Code Mirror?

It is the text editor used in the dev tools for Firefox, Chrome, and Safari, in Light Table, Adobe Brackets, Bitbucket, and many other projects. CodeMirror is an open-source project shared under an MIT license.

What happens if the sender does not receive an ACK?

It resubmits the package

What does a compiler do?

It translates the human-readable source code of a high-level programming language into machine code.

What is a checksum?

It's a check for possible errors during a submission, representing the contents of a file as a single integer, done by converting all characters to numbers and summing them.

What do we call a function that has side effects? Is it really a function?

It's really a procedure because functions do not have side effects.

Are Java and other object-oriented languages pass by reference or pass by value?

Java, C#, Python, Ruby, JavaScript, and PHP are actually pass-by-value languages. (C# and PHP have the "ref" keyword and the "&" sigil respectively for passing by reference.) Some of these languages (Python and Ruby) have no concept of "primitives." What happens in all of these languages when passing objects as arguments goes by the names "call by sharing" or "passing references by value," but this is not to be confused with pass-by-reference behavior (which you find in Fortran). Java is always pass-by-value.Unfortunately, we never handle an object at all, instead juggling object-handles called references (which are passed by value of course). The chosen terminology and semantics easily confuse many beginners.It goes like this:public static void main(String[] args) { Dog aDog = new Dog("Max"); Dog oldDog = aDog; // we pass the object to foo foo(aDog); // aDog variable is still pointing to the "Max" dog when foo(...) returns aDog.getName().equals("Max"); // true aDog.getName().equals("Fifi"); // false aDog == oldDog; // true } public static void foo(Dog d) { d.getName().equals("Max"); // true // change d inside of foo() to point to a new Dog instance "Fifi" d = new Dog("Fifi"); d.getName().equals("Fifi"); // true }In the example above aDog.getName() will still return "Max". The value aDog within main is not changed in the function foo with the Dog "Fifi" as the object reference is passed by value. If it were passed by reference, then the aDog.getName() in main would return "Fifi" after the call to foo.Likewise:public static void main(String[] args) { Dog aDog = new Dog("Max"); Dog oldDog = aDog; foo(aDog); // when foo(...) returns, the name of the dog has been changed to "Fifi" aDog.getName().equals("Fifi"); // true // but it is still the same dog: aDog == oldDog; // true } public static void foo(Dog d) { d.getName().equals("Max"); // true // this changes the name of d to be "Fifi" d.setName("Fifi"); }In the above example, Fifi is the dog's name after call to foo(aDog) because the object's name was set inside of foo(...). Any operations that foo performs on d are such that, for all practical purposes, they are performed on aDog, but it is not possible to change the value of the variable aDog itself.

What are microservices?

Like SOA, microservices architectures are made up of loosely coupled, reusable, and specialized components. However, rather than being adopted enterprise-wide, microservices are typically used to build individual applications in a way that makes them more agile, scalable, and resilient. Microservices are a true cloud native architectural approach, and by using them, teams can update code more easily, use different stacks for different components, and scale the component independently of one another, reducing the waste and cost associated with having to scale entire applications because a single feature might be facing too much load.

What is link rot?

Link rot is the phenomenon of hyperlinks tending over time to cease to point to their originally targeted file, web page, or server due to that resource being relocated or becoming permanently unavailable.

What does LAN stand for?

Local Area Network

Can many packets be sent through TCP at once, or just one?

Many

What is memoization?

Memoization is a term introduced by Donald Michie in 1968, which comes from the latin word memorandum (to be remembered). Memoization is a method used in computer science to speed up calculations by storing (remembering) past calculations. If repeated function calls are made with the same parameters, we can store the previous values instead of repeating unnecessary calculations. In this post, we will use memoization to find terms in the Fibonacci sequence.

What is a packet's header?

Metadata in front of the data payload

What's the difference between an ORM (Object Relational Mapper) and an ODM (Object Document Mapper)?

MySQL is an example of a relational database - you would use an ORM to translate between your objects in code and the relational representation of the data. Examples of ORMs are nHibernate, Entity Framework, Dapper and more... MongoDB is an example of a document database - you would use an ODM to translate between your objects in code and the document representation of the data (if needed).

What is NGINX?

Nginx, stylized as NGINX, nginx or NginX, is a web server that can also be used as a reverse proxy, load balancer, mail proxy and HTTP cache. The software was created by Igor Sysoev and publicly released in 2004. Nginx is free and open-source software, released under the terms of the 2-clause BSD license.

Does the checksum feature in UDP headers provide a way to fix any errors or fix a copy of the packet being sent?

No

Does the sender (server) know whether or not data transfer through UDP was successful or not?

No (though notification of corruption is sent to the client)

Do you have control over the content of resources hosted by a CDN?

No. CDNs host very specific content most of the time. We don't control over the content - it's a take it or leave it situation! Most likely, our CDN keeps its content on many servers throughout the world. We neither own nor maintain it!

What does OSI stand for in the OSI model?

Open system interconnection

What are the core benefits of a PWA?

Optimal Progressive Web App checklist To create a truly great Progressive Web App, one that feels like a best-in-class app, you need more than just the core checklist. The optimal Progressive Web App checklist is about making your PWA feel like it's part of the device it's running on while taking advantage of what makes the web powerful. Provides an offline experience Where connectivity isn't strictly required, your app works the same offline as it does online. Is fully accessible All user interactions pass WCAG 2.0 accessibility requirements. Can be discovered through search Your PWA can be easily discovered through search. Works with any input type Your PWA is equally usable with a mouse, a keyboard, a stylus, or touch. Provides context for permission requests When asking permission to use powerful APIs, provide context and ask only when the API is needed. Follows best practices for healthy code Keeping your codebase healthy makes it easier to meet your goals and deliver new features.

How many domain names have been registered?

Over 300 million

What kind of sorting algorithm is used to organize objects occluding other objects, from farthest to closest, and why are they called that?

Painter's algorithms, because painters also have to start with the background and increasingly workup toward foreground elements

What does the transport layer of the OSI entail?

Point to point transfer of data between computers Error detection Recovery from errors

What does the data link layer of the OSI entail?

Processes that mediate access to the physical layer MAC addresses Collision detection Exponential backoff Similar low-level protocols

What happens when checksum numbers do not match?

Programs are alerted to the corruption and the packet is discarded

What does the session layer of the OSI entail?

Protocols like UDP and TCP being able to open data connections, pass data back and forth, and close connections when finished.

What does the network layer of the OSI entail?

Routing and switching technologies

What is runtime?

Runtime is the period of time when a program is running. It begins when a program is opened (or executed) and ends with the program is quit or closed. Runtime is a technical term, used most often in software development. It is commonly seen in the context of a "runtime error," which is an error that occurs while a program is running. The term "runtime error" is used to distinguish from other types of errors, such as syntax errors and compilation errors, which occur before a program is run. When a program is in the runtime phase, the application is loaded into RAM. This includes the executable file and any libraries, frameworks, or other files referenced by the program. When the program is quit, the runtime period ends and the memory used by the program is made available for use by other programs. Runtime is the final phase of the program lifecycle in which the machine executes the program's code. The other phases include: Edit time - When the source code of the program is being edited. This phase includes bug fixing, refactoring, and adding new features. Compile time - When the source code is translated into machine code by a compiler. The result is an executable. Link time - When all the necessary machine code components of a program are connected such as external libraries. These connections can be made by the compiler (called static linking) or by the operating system (called dynamic linking). Distribution time - When a program is transferred to a user as an executable or source code. Most of the time a program is downloaded from the Internet but it can also be distributed via CD or USB drive. Installation time - When the distributed program is being installed on the user's computer. Load time - When the operating system places the executable in active memory in order to begin execution. How Runtime Works When a user tries to start a program a loader runs that allocates memory and links the program with any necessary libraries, then the execution begins. Many people who use computer programs understand the runtime process; however, runtime is very important to software developers because if errors are found in the code the program will throw runtime errors. Runtime errors If a program experiences an error after it has been executed it will report back a runtime error. There are hundreds of different errors that programs can experience such as division by zero errors, domain errors, and arithmetic underflow errors. Some programming languages have built-in exception handling which is designed to handle any runtime errors the code encounters. Exception handling can catch both predictable and unpredictable errors without excessive inline, manual error checking. Taking Java as an example, there are multiple ways to implement exception handling. Below we will cover try-catch blocks and throws. The following type of exception handling is called a try-catch block. It tells the program to try a block of code and, if it doesn't work, catch the exception and run another block of code: public static String readFirstLine(String url) { try { Scanner scanner = new Scanner(new File(url)); return scanner.nextLine(); } catch(FileNotFoundException ex) { System.out.println("File not found."); return null; } } The next type of exception handling is called a throw. It tells the program to explicitly throw an exception object if specific criteria are met: public class ThrowExample { static void checkEligibilty(int stuage, int stuweight){ if(stuage<12 && stuweight<40) { throw new ArithmeticException("Student is not eligible for registration"); } else { System.out.println("Student Entry is Valid!!"); } } public static void main(String args[]){ System.out.println("Welcome to the Registration process!!"); checkEligibilty(10, 39); System.out.println("Have a nice day.."); } } //If the student does not meet the necessary criteria, //we will encounter the following error message. Welcome to the Registration process!!Exception in thread "main" java.lang.ArithmeticException: Student is not eligible for registration Examples of Runtime Developers can manipulate and send instructions to a program while testing their program in a runtime environment (RTE). One of the most popular runtime environments for JavaScript is Node.js. JavaScript is primarily a client-side language but this open-source runtime environment allows for the creation of web servers and networking tools using JavaScript. Many major corporations implement Node.js in their development such as Netflix, LinkedIn, Walmart, Uber, eBay, and PayPal. Another runtime environment that is popularly used is Android Runtime (ART). As expected, it is used by the Android operating system to perform the translation of bytecode into native instructions. ART uses a hybrid combination of ahead-of-time (AOT) compilation, just-in-time (JIT) compilation, and profile-guided compilation to drastically increase app performance. Key Takeaways Runtime is the phase of the program lifecycle that executes and keeps a program running; other phases include edit time, compile time, link time, distribution time, installation time, and load time. Developers often test their programs in runtime environments (RTE) before moving to production in order to check for performance glitches and runtime errors. Runtime errors can be customized in most languages; in JavaScript, a custom message can be displayed with a standard error block by using throw.

What is an example embedded database systems I've used?

SQLite and H2

Name a popular algorithm for making a mesh.

Scanline rendering

xxx

Screen reading software JAWS screen reading software

What is SOA?

Service-oriented architecture. It defines a way to make software components reusable and interoperable via service interfaces. Services use common interface standards and an architectural pattern so they can be rapidly incorporated into new applications. This removes tasks from the application developer who previously redeveloped or duplicated existing functionality or had to know how to connect or provide interoperability with existing functions. Each service in an SOA embodies the code and data required to execute a complete, discrete business function (e.g. checking a customer's credit, calculating a monthly loan payment, or processing a mortgage application). The service interfaces provide loose coupling, meaning they can be called with little or no knowledge of how the service is implemented underneath, reducing the dependencies between applications. This interface is a service contract between the service provider and service consumer. Applications behind the service interface can be written in Java, Microsoft .Net, Cobol or any other programming language, supplied as packaged software applications by a vendor (e.g., SAP), SaaS applications (e.g., Salesforce CRM), or obtained as open source applications. Service interfaces are frequently defined using Web Service Definition Language (WSDL) which is a standard tag structure based on xml (extensible markup language). The services are exposed using standard network protocols—such as SOAP (simple object access protocol)/HTTP or Restful HTTP (JSON/HTTP)—to send requests to read or change data. Service governance controls the lifecycle for development and at the appropriate stage the services are published in a registry that enables developers to quickly find them and reuse them to assemble new applications or business processes. These services can be built from scratch but are often created by exposing functions from legacy systems of record as service interfaces. In this way, SOA represents an important stage in the evolution of application development and integration over the last few decades. Before SOA emerged in the late 1990s, connecting an application to data or functionality housed in another system required complex point-to-point integration—integration that developers had to recreate, in part or whole, for each new development project. Exposing those functions through SOA services allowed the developer to simply reuse the existing capability and connect through the SOA ESB architecture (see below). Note that although SOA, and the more recent microservices architecture, share many words in common(i.e. "service" and "architecture"), they are only loosely related and, in fact, operate at different scopes, as discussed later in this article. What is service-oriented architecture (SOA)? Service-oriented architecture (SOA) is an enterprise-wide approach to software development that takes advantage of reusable software components, or services. Each service is comprised of the code and data integrations required to execute a specific business function—for example, checking a customer's credit, signing in to a website, or processing a mortgage application. The service interfaces provide loose coupling, which means that they can be called with little or no knowledge of how the integration is implemented underneath. Because of this loose coupling and the way the services are published, developers can save time by reusing components in other applications across the enterprise. SOA emerged in the late 1990s and represents an important stage in the evolution of application development and integration. Before SOA was an option, connecting an application to data or functionality in another system required complex point-to-point integration that developers had to recreate for each new development project. Exposing those functions through SOA eliminates the need to recreate the deep integration every time.

Give an example of an application that uses UDP?

Some streaming apps, such as Skype, in which missing packets are acceptable

This will explain 3 simple steps to use Reactive programming in your application (in Java) (see image).

Step-1 Create observable that emits the data: Here database is an observable which emits the data. In our case, it emits the strings. just() is an operator. Which basically emits the data provided in the argument one by one. (We are going to look into the operators in detail in our upcoming articles. So, don't worry about them.) Step -2 Create observer that consumes data: In above code snippet observer is an observer that consumes the data emitted by the database observable. It processes the data received and also handles error inside it. Step-3 Manage concurrency : At the last step, we define our schedulers that manage the concurrency. subscribeOn(Schedulers.newThread()) tells database observable to run on background thread. observeOn(AndroidSchedulers.mainThread()) tells observer to run on the main thread. This is basic code for reactive programming. Observable<String> database = Observable //Observable. This will emit the data .just(new String[]{"1", "2", "3", "4"}); //Operator Observer<String> observer = new Observer<String>() { @Override public void onCompleted() { //... } @Override public void onError(Throwable e) { //... } @Override public void onNext(String s) { //... } }; database.subscribeOn(Schedulers.newThread()) //Observable runs on new background thread. .observeOn(AndroidSchedulers.mainThread()) //Observer will run on main UI thread. .subscribe(observer); //Subscribe the observer

What are surrogates in regard to UTF?

Surrogates are code points from two special ranges of Unicode values, reserved for use as the leading, and trailing values of paired code units in UTF-16. Leading, also called high, surrogates are from D80016 to DBFF16, and trailing, or low, surrogates are from DC0016 to DFFF16. They are called surrogates, since they do not represent characters directly, but only as a pair.

What is a WAN?

Systems of LANs that are connected

Do video streaming services usually use UDP or TCP?

TCP

How are TCP headers and UDP headers different?

TCP headers include sequential numbers that allow different packets to be assembled in order even if they arrive at different times across the network

What premise is functional programming based on?

That your functions should not have side effects; they are considered evil in this paradigm.

What is the Unix philosophy?

The Unix philosophy, originated by Ken Thompson, is a set of cultural norms and philosophical approaches to minimalist, modular software development. It is based on the experience of leading developers of the Unix operating system. Early Unix developers were important in bringing the concepts of modularity and reusability into software engineering practice, spawning a "software tools" movement. Over time, the leading developers of Unix (and programs that ran on it) established a set of cultural norms for developing software; these norms became as important and influential as the technology of Unix itself; this has been termed the "Unix philosophy." The Unix philosophy emphasizes building simple, short, clear, modular, and extensible code that can be easily maintained and repurposed by developers other than its creators. The Unix philosophy favors composability as opposed to monolithic design.

What is referential transparency?

The ability to replace an expression with its calculated value Think this: "What an expression results in has no hidden side effects; its value is always transparent." Referential transparency is important because it allows us to substitute expressions with values. This property enables us to think and reason about the program evaluation using the substitution model. Hence, we can say that expressions that can be replaced by values are deterministic, as they always return the same value for a given input.

The Client Tier

The clientele is up the browser. The browser software is installed on the user's computer. Whether that's desktop or a laptop computer or immobile device such as smartphone or tablet the job of the browser is to send request to the server and then receive and render 80 male images. Cascading Style Sheets and other essays. All modern web browsers can also execute client side code. Such as a metal markup and Javascript. And in many cases they can run plugins such as Flash Player or java

What is TCP/IP?

The combination of IP and TCP protocols.

What's the difference between .tar.gz and .zip?

The main difference between the two formats is that in ZIP, compression is built-in and happens independently for every file in the archive, but for tar, compression is an extra step that compresses the entire archive.

What is bandwidth?

The maximum amount of data transmitted over an internet connection in a given amount of time. Bandwidth is often mistaken for internet speed when it's actually the volume of information that can be sent over a connection in a measured amount of time - calculated in megabits per second (Mbps).

What are some main differences between SOA and microservices?

The main distinction between the two approaches comes down to scope. To put it simply, service-oriented architecture (SOA) has an enterprise scope, while the microservices architecture has an application scope. Many of the core principles of each approach become incompatible when you neglect this difference. If you accept the difference in scope, you may quickly realize that the two can potentially complement each other, rather than compete. Here are a few cases where this distinction comes into play: Reuse In SOA, reuse of integrations is the primary goal, and at an enterprise level, striving for some level of reuse is essential. In microservices architecture, creating a microservices component that is reused at runtime throughout an application results in dependencies that reduce agility and resilience. Microservices components generally prefer to reuse code by copy and accept data duplication to help improve decoupling. Synchronous calls The reusable services in SOA are available across the enterprise using predominantly synchronous protocols such as RESTful APIs. However, within a microservice application, synchronous calls introduce real-time dependencies, resulting in a loss of resilience. It may also cause latency, which impacts performance. Within a microservices application, interaction patterns based on asynchronous communication are preferred, such as event sourcing, in which a publish/subscribe model is used to enable a microservices component to remain up to date on changes happening to the data in another component. Data duplication A clear aim of providing services in an SOA is for all applications to synchronously get hold of and make changes to data directly at its primary source, which reduces the need to maintain complex data synchronization patterns. In microservices applications, each microservice ideally has local access to all the data it needs to ensure its independence from other microservices, and indeed from other applications, even if this means some duplication of data in other systems. Of course, this duplication adds complexity, so it must be balanced against the gains in agility and performance, but this is accepted as a reality of microservices design. Other key differences between SOA and microservices Communication: In a microservices architecture, each service is developed independently, with its own communication protocol. With SOA, each service must share a common communication mechanism called an enterprise service bus (ESB). The ESB can become a single point of failure for the whole enterprise, and if a single service slows down, the entire system can be effected. Interoperability: In the interest of keeping things simple, microservices use lightweight messaging protocols like HTTP/REST. SOAs are more open to heterogeneous messaging protocols. Service granularity: Microservices architectures are made up of highly specialized services, each of which is designed to do one thing very well. The services that make up SOAs, on the other hand, can range from small, specialized services to enterprise-wide services. Speed: By leveraging the advantages of sharing a common architecture, SOAs simplify development and troubleshooting. However, this also tends to make SOAs operate more slowly than microservices architectures, which minimize sharing in favor of duplication. SOA vs. microservices: Which is best for you? Both approaches have their advantages, so how can you determine which one will work best for your purposes? In general, it depends on how large and diverse your application environment is. Larger, more diverse environments lend themselves more to service-oriented architecture (SOA), which supports integration between heterogenous applications and messaging protocols via an enterprise-service bus (ESB). Smaller environments, including web and mobile applications, don't require such a robust communication layer and are easier to develop using a microservices architecture.

What happens if a packet ends up being received after it has been retransmitted because the original acknowledgement was lost or delayed?

The old packet is simply removed

What is URI normalization?

The process by which URIs are modified and standardized in a consistent manner. The goal of the normalization process is to transform a URI into a normalized URI so it is possible to determine if two syntactically different URIs may be equivalent.

What can be inferred from the back and forth between packets being sent and acknowledgements being sent and the rate of ACK success?

The rate of congestion

What is throughput?

The rate of production or the rate at which something is processed. When used in the context of communication networks, such as Ethernet or packet radio, throughput or network throughput is the rate of successful message delivery over a communication channel. The data these messages belong to may be delivered over a physical or logical link, or it can pass through a certain network node. Throughput is usually measured in bits per second (bit/s or bps), and sometimes in data packets per second (p/s or pps) or data packets per time slot.

What is an "ACK"?

The required acknowledgement sent by the client computer to the sending computer that a request has been received and that it has passed the checksum.

What are the three pillars of progressive web apps?

The three app pillars # Progressive Web Apps are web applications that have been designed so they are capable, reliable, and installable. These three pillars transform them into an experience that feels like a platform-specific application. Capable # The web is quite capable in its own right today. For example, you can build a hyper-local video chat app using WebRTC, geolocation, and push notifications. You can make that app installable and take those conversations virtual with WebGL and WebVR. With the introduction of Web Assembly, developers can tap into other ecosystems, like C, C++, and Rust, and bring decades of work and capabilities to the web too. Squoosh.app, for instance, leverages this for its advanced image compression. Until recently, only platform-specific apps could really lay claim to these capabilities. While some capabilities are still out of the web's reach, new and upcoming APIs are looking to change that, expanding what the web can do with features like file system access, media controls, app badging, and full clipboard support. All of these capabilities are built with the web's secure, user-centric permission model, ensuring that going to a website is never a scary proposition for users. Between modern APIs, Web Assembly, and new and upcoming APIs, web applications are more capable than ever, and those capabilities are only growing. Reliable # A reliable Progressive Web App feels fast and dependable regardless of the network. Speed is critical for getting users to use your experience. In fact, as page load times go from 1 second to ten seconds, the probability of a user bouncing increases by 123%. Performance doesn't stop after the onload event. Users should never wonder whether their interaction—for example, clicking a button—was registered or not. Scrolling and animation should feel smooth. Performance affects your entire experience, from how users perceive your application to how it actually performs. Finally, reliable applications need to be usable regardless of network connection. Users expect apps to start up on slow or flaky network connections or even when offline. They expect the most recent content they've interacted with, like media tracks or tickets and itineraries, to be available and usable even if getting a request to your server is hard. When a request isn't possible, they expect to be told there's trouble instead of silently failing or crashing. Users love apps that respond to interaction in the blink of an eye, and an experience they can depend on. Installable # Installed Progressive Web Apps run in a standalone window instead of a browser tab. They're launchable from on the user's home screen, dock, taskbar, or shelf. It's possible to search for them on a device and jump between them with the app switcher, making them feel like part of the device they're installed on. New capabilities open up after a web app is installed. Keyboard shortcuts usually reserved when running in the browser, become available. Progressive Web Apps can register to accept content from other applications, or to be the default application to handle different types of files. When a Progressive Web App moves out of a tab and into a standalone app window, it transforms how users think about it and interact with it

What does "write once, run anywhere" refer to?

The way a programming language is not restricted to a particular computer

What's the difference between the world wide web and the Internet?

The world wide web, or web for short, are the pages you see when you're at a device and you're online. But the internet is the network of connected computers that the web works on, as well as what emails and files travel across The Internet is like the roads and the world wide web contains the things you see on the roads like houses and shops.

How many Unicode characters are there currently?

There are 17×216 - 2048 - 66 = 1,111,998 possible Unicode characters: seventeen 16-bit planes, with 2048 values reserved as surrogates, and 66 reserved as non-characters. More on this below.

How are TCP headers and UDP headers similar?

They both use port numbers and checksums

How do you use the traceroute program on the three main operating systems?

Traceroute on Windows 1. Press the Start Button 2. Type "CMD" and press "Enter" 3. In the Command Prompt type "tracert dftba.com" Traceroute on Mac 1. Click on the "Go" drop down menu 2. Click on "Utilities" 3. Open Terminal 4. Type "traceroute dftba.com" Traceroute on Linux 1. Open Terminal by typing CTRL+Alt+T 2. Type: "traceroute dftba.com"

What does TCP allow you to do?

Transfer data without information missing due to possible service interruptions

What does TCP stand for?

Transmission Control Protocol

What does UTF stand for?

Unicode transformation format

How can you see all of the IPs your WAN and LAN are gone through in order to provide access to a specific website?

Use the traceroute program on your computer.

splash page

Used to capture the user's attention for a short time.

What benefits come from a function not having side effects?

We can execute it any time and it will always return the same result, given the same input.

xxx

Weaving, so that means connecting aspects to target objects to create an advised object. So, there's different types of weaving, you have compile-time weaving, load-time weaving or run-time weaving. And then, in regards of performance, run-time weaving is the slowest because it kind of happens at run-time.

When is short-circuiting problematic?

When a function needs to be executed after the condition no matter what ??? depends on parts of the conditional statement that determine an execution ???

What is occlusion in digital imaging?

When objects are hidden behind others

What does WAN stand for?

Wide Area Network

What is Objective-C?

a general-purpose, object-oriented programming language that adds Smalltalk-style messaging to the C programming language. 1990s -- Python, Ruby, Java

What is a multi-tier application?

a web application

What is a variable?

an abstraction for a needed memory location

What is a UTF?

an algorithmic mapping from every Unicode code point (except surrogate code points) to a unique byte sequence

Is it best to have just client-side validation, server-side validation, or both?

both

What is curl (cURL)?

cURL is a command-line tool for getting or sending data including files using URL syntax. Since cURL uses libcurl, it supports every protocol libcurl supports. cURL supports HTTPS and performs SSL certificate verification by default when a secure protocol is specified such as HTTPS. curl is a a command line tool that allows to transfer data across the network. It supports lots of protocols out of the box, including HTTP, HTTPS, FTP, FTPS, SFTP, IMAP, SMTP, POP3, and many more. When it comes to debugging network requests, curl is one of the best tools you can find.

What is used with shapes that are more complex than, say, a cube?

polygons -- triangular forms

What is antialiasing in digital imaging?

smoothing the jagged edges of a digital image by softening the same color that is used to fill the image

Why are triangles used instead of squares, polygons, or other complex shapes to make a mesh?

triangles unambiguously define a plane; you can draw a plane through a triangle in a 3d space and it will be unambiguous, but it's not guaranteed to be true for shapes with four or more points. And two sides aren't enough to define a plane.

xxx

different Advice Types as for as when you should run the code. So they have the before advice, that means run the code before the actual method executes, and likewise they have the after finally advice that means run the code after the method finishes, like the finally block of a Try-Catch. Then you have the after returning advice, so run this piece of code after the method for a successful execution, and also, after throwing advice, meaning run this code after the method finished, if an exception's thrown. And also the around advice, so you can run the code before and after the method,

Is JavaScript pass by value or pass by reference?

In JavaScript, all function arguments are always passed by value. It means that JavaScript copies the values of the passing variables into arguments inside of the function. Any changes that you make to the arguments inside the function does not affect the passing variables outside of the function. In other words, the changes made to the arguments are not reflected outside of the function. If function arguments are passed by reference, the changes of variables that you pass into the function will be reflected outside the function. This is not possible in JavaScript.

Why should you include a message that reads "Your browser doesn't support the audio tag!" when embedding audio and video files in a website?

In case a user has a very old browser that doesn't support HTML5 (WAV, MP3, and OGG file types are not supported)

What is code smell?

In computer programming, a code smell is any characteristic in the source code of a program that possibly indicates a deeper problem One way to look at smells is with respect to principles and quality: "Smells are certain structures in the code that indicate violation of fundamental design principles and negatively impact design quality".[6] Code smells are usually not bugs; they are not technically incorrect and do not prevent the program from functioning. Instead, they indicate weaknesses in design that may slow down development or increase the risk of bugs or failures in the future. Bad code smells can be an indicator of factors that contribute to technical debt.[1] Robert C. Martin calls a list of code smells a "value system" for software craftsmanship.[7]

xxx

In computer programming, self-documenting (or self-describing) source code and user interfaces follow naming conventions and structured programming conventions that enable use of the system without prior specific knowledge.[1] In web development, self-documenting refers to a website that exposes the entire process of its creation through public documentation, and whose public documentation is part of the development process.[citation needed] Contents 1Objectives 2Conventions 3Practical considerations 4Examples 5Criticism 6See also 7References 8Further reading Objectives[edit] Commonly stated objectives for self-documenting systems include: Make source code easier to read and understand[2] Minimize the effort required to maintain or extend legacy systems[2] Reduce the need for users and developers of a system to consult secondary documentation sources such as code comments or software manuals[2] Facilitate automation through self-contained knowledge representation Conventions[edit] Self-documenting code is ostensibly written using human-readable names, typically consisting of a phrase in a human language which reflects the symbol's meaning, such as article.numberOfWords or TryOpen. The code must also have a clear and clean structure so that a human reader can easily understand the algorithm used. Practical considerations[edit] There are certain practical considerations that influence whether and how well the objectives for a self-documenting system can be realized. uniformity of naming conventions[2] consistency[2] scope of the application and system requirements

What is CGI in computing?

In computing, Common Gateway Interface (CGI) is an interface specification that enables web servers to execute an external program, typically to process user requests.[1] Such programs are often written in a scripting language and are commonly referred to as CGI scripts, but they may include compiled programs.[2] A typical use case occurs when a Web user submits a Web form on a web page that uses CGI. The form's data is sent to the Web server within an HTTP request with a URL denoting a CGI script. The Web server then launches the CGI script in a new computer process, passing the form data to it. The output of the CGI script, usually in the form of HTML, is returned by the script to the Web server, and the server relays it back to the browser as its response to the browser's request.[3] Developed in the early 1990s, CGI was the earliest common method available that allowed a Web page to be interactive. Although still in use, CGI is relatively inefficient compared to newer technologies and has largely been replaced by them.[4] For each incoming HTTP request, a Web server creates a new CGI process for handling it and destroys the CGI process after the HTTP request has been handled. Creating and destroying a process can consume much more CPU and memory than the actual work of generating the output of the process, especially when the CGI program still needs to be interpreted by a virtual machine. For a high number of HTTP requests, the resulting workload can quickly overwhelm the Web server. The overhead involved in CGI process creation and destruction can be reduced by the following techniques: CGI programs precompiled to machine code, e.g. precompiled from C or C++ programs, rather than CGI programs interpreted by a virtual machine, e.g. Perl, PHP or Python programs. Web server extensions such as Apache modules (e.g. mod_perl, mod_php, mod_python), NSAPI plugins, and ISAPI plugins which allow long-running application processes handling more than one request and hosted within the Web server. Web 2.0 allows to transfer data from the client to the server without using HTML forms and without the user noticing.[14] FastCGI, SCGI, and AJP which allow long-running application processes handling more than one request hosted externally to the Web server. Each application process listens on a socket; the Web server handles an HTTP request and sends it via another protocol (FastCGI, SCGI or AJP) to the socket only for dynamic content, while static content are usually handled directly by the Web server. This approach needs less application processes so consumes less memory than the Web server extension approach. And unlike converting an application program to a Web server extension, FastCGI, SCGI, and AJP application programs remain independent of the Web server. Jakarta EE runs Jakarta Servlet applications in a Web container to serve dynamic content and optionally static content which replaces the overhead of creating and destroying processes with the much lower overhead of creating and destroying threads. It also exposes the programmer to the library that comes with Java SE on which the version of Jakarta EE in use is based. The optimal configuration for any Web application depends on application-specific details, amount of traffic, and complexity of the transaction; these tradeoffs need to be analyzed to determine the best implementation for a given task and time budget. Web frameworks offer an alternative to using CGI scripts to interact with user agents.

What is an OS?

Software that handles your computer's memory and processes

What are some benefits of TCP over UDP?

TCP is well established It provides packet ordering It provides retransmissions It prevents packet loss It can handle out of order package delivery it can handle dropped packages It can throttle its transmission rate according to available bandwidth

xxx

So the most basic element is an Aspect, so it's a module of code for cross-cutting concerns. And then we have the Advice, so this is basically what action is taken and when it should be applied. Next we have the idea of a Join Point, so that's basically when to apply the code during program execution, and finally we have a Pointcut, that's a predicate expression for where the advice should be applied.

xxx

So here are the benefits of AOP or kind of why AOP. The code for the aspect is defined in a single class so it's much better than scattering the code everywhere, and it also promotes code reuse, and it's easier to change. And also, the business code in your application is cleaner, so you only write the code specific to your business like add account, and you simply save it to the database. It reduces the code complexity. Also, this thing is configurable, so based on the configuration you can apply aspects selectively to different parts of your application. No need to make changes to the main application code, that's very important, simply apply the aspects to your configs and you're ready to go. Alrighty, now here are some additional AOP use cases. So the most common ones that you'll hear about with AOP is logging, security, and transactions. So Spring actually makes use of security and transactions in the background, kind of out of the box. You can also make use of audit logging, so you can log who, what, when, where or you get a method that's called. You can also add an aspect for exception handling, so if there's an exception anywhere in our system let's log that exception and then let's notify the DevOps team by either sending them an SMS message or sending them an email, and you can kind of customize that based on your own company. Or you can use it for API management. So you could say hey, how many times has a method been called by a user? Perform some analytics, what are the peak times for our API methods being called, what's the average load, who's the top user? So on and so forth, and you can kind of get all that information by kind of setting up these aspects and kind of spying or listening in on all of the message traffic or method calls and track data, record all of it, so some very good examples there. And now let's talk about advantages and disadvantages, alright? (laughs) So advantages here, reusable modules, resolves code tangling, resolves code scatter, and you can apply it selectively based on the configuration. Alrighty, so let's talk about disadvantages. Well, if you have too many aspects then your app flow can be hard to follow. So imagine a project with 20 developers or 100 developers, they're each creating their own set of 10 to 20 aspects and applying them system-wide, it's really hard to figure out what's being called and so on. You simply can't look at the main code, you have to go and look at all the other aspects and look at the configuration for those, so it can become challenging. So the key here is that use the aspects in moderation and make use of some rules and governance on your team to have a good idea as far as the aspect development, as far as who's creating them and who's applying them. Also there's a minor performance cost for aspect execution if you're using run-time weaving, which Spring AOP makes use of. So it's a small performance hit, not a big deal, it's like nanoseconds, milliseconds, but again you don't want to overdo it. So if you have a small number of aspects you may not even notice it, but if you start to add a lot of aspects in there that perform very expensive operations then you'll definitely feel it. So again, just use it in moderation. And also you have to kind of look at your system and think about the advantages and disadvantages, like do the advantages outweigh the disadvantages? I mean, if you didn't use AOP you'd have to go back and manually update a hundred classes or 200 classes. So again, pros and cons, you have to weigh it accordingly. But AOP is being used in the real world on a number of large-scale, real-time projects, so it's a proven technology and it's definitely something you should take a look at and apply it on your upcoming projects. Alright, so that's it for now with AOP.

What can characterize a function that has side effects?

1. It modifies a mutable data structure or variable 2. It uses IO 3. It throws an exception or halts an error

What are three benefits of using a CDN?

1. Loads resources very efficiently 2. Enables resource use without being hosted directly 3. Boosts reliability. A CDN is quite reliable during all periods of activity. When a user accesses the website, the CDN pulls information from the nearest server; if that server isn't available, it will move to the second nearest server location. The automatic redundancy feature helps ensure that your website is online at all times. So not only does the CDN help when traffic spikes, it also helps if a server connection is compromised somewhere in the chain of information. While users can't actually see any of this - it's happening in nanoseconds - it makes a difference for the user because your website won't keep them waiting. 4. Reduced Server Load 5. A CDN stores multiple content types, which can contribute to faster loading times for users. And because the CDN stores this content it can push it to users more quickly. 6. Because of the method through which a CDN serves data to users, it can use less overall bandwidth across multiple servers. If you are paying for hosting based on bandwidth, using a CDN can help reduce these costs. The bandwidth reduction happens because multiple server locations are used to serve content to users, so not all inquiries to your website are hitting the origin server at the same time. 7. Because of faster loading speed and performance, a CDN can also improve your search engine rankings and optimization. (That's a great added bonus!) Google gives priority to websites that load quickly and that are easy to crawl repeatedly. The more often Google crawls your website, the more quickly it will recognize content changes and updates related to your content. This quick turnaround for search indexing will help get your content into more search results faster. Content that's indexed faster is more widely available to users. It's all part of a cycle that starts with the health of your website. Even some of the more technical aspects of the website framework and design can impact how users find and consume your content. 8. The CDN also provides an extra level of security which can mitigate attacks. Plus, you can combine a CDN with an SSL certificate for one more level of security. Security is another factor when it comes to search, and can also contribute to better search indexing and rankings. 9. It helps with traffic spikes. Because a significant portion of website traffic is static - it's not constantly changing - a CDN can ensure that content is delivered quickly and put less pressure, or load, on your server. Less load means there's less chance of downtime. A CDN is designed for scalability so that you can handle changes in traffic (up or down) with ease and without learning of a traffic change because of a website that's no longer functioning.

What are some practical ways a developer can make a website more accessible?

1. Use alt tags 2. Use identifiable link text ... Indicate a link is present by saying "a link is here" instead of just making a link out of text that doesn't do that 3. Identify input purpose ... Use an html label's for attribute, along with the id property 4. For headers use a. only one h1 per page b. proper nesting (don't skip header levels) c. use descriptive text 5. Provide captions for recorded sound and video 6. Provide captions for live sound and video 7. Don't have content with more than 3 flashes per second 8. Avoid directions that rely solely on recognition of color, for example, "Click the purple button to continue" 9. Make sure the ratio between text and background color is at least 4.5 to 1 .... you can use WebAIM's color contrast checker for this 10. Make page navigation easy for keyboard operation, in the possible absence of a mouse or trackpad ... websites should be navigable by keyboard shortcuts alone 11. Some sites have dozens of links in the navbar. Let people out of this "trap" by providing a Skip navigation or Skip to main content link at the top of the page. 12. Use Accessible Rich Internet Applications (ARIA) controls ... by adding attributes to existing HTML elements to help identify their purpose. It's not always obvious what HTML is doing just by looking at it. This is particularly true for JavaScript-enabled widgets (e.g., tabpanels 13. Use semantic HTML elements instead of just divs 14. Use the role attribute, which defines the purpose of an element, such as a button, along with id and area-labelledby properties 15. accessible drop-down menus allow those with visual impairments the ability to click through all pages of a website.

What is a mesh?

A 3d shape made with a collection of polygons. The denser the mesh, the smoother the curves and the finer the details

Why are CDN page loads faster than not using a CDN for the same resource?

A CDN shortens the path information has to travel between the server and user. A CDN is a network of servers, rather than a single server, with locations in multiple geographic locations. When a user accesses a website, information is pulled from the server location closest to them. The result is a faster flow of data.

What is UTF-8, UTF-16, and UTF-32?

A Unicode-based encoding such as UTF-8 can support many languages and can accommodate pages and forms in any mixture of those languages. Its use also eliminates the need for server-side logic to individually determine the character encoding for each page served or each incoming form submission.

What is the OSI model?

A conceptual model for compartmentalizing all network processes

xxx

A database dump (also: SQL dump) contains a record of the table structure and/or the data from a database and is usually in the form of a list of SQL statements. A database dump is most often used for backing up a database so that its contents can be restored in the event of data loss.

What is reactive (Rx) programming?

A programming paradigm oriented around data flows and the propagation of change. This means that it should be possible to express static or dynamic data flows with ease in the programming languages used, and that the underlying execution model will automatically propagate changes through the data flow. In simple words, In Rx programming data flows emitted by one component and the underlying structure provided by the Rx libraries will propagate those changes to another component that are registered to receive those data changes. 3 simple steps to use Rx in your application General Marble Diagram Let's look into the basic example. This will explain 3 simple steps to use Reactive programming in your application. Step-1 Create observable that emits the data: Here database is an observable which emits the data. In our case, it emits the strings. just() is an operator. Which basically emits the data provided in the argument one by one. (We are going to look into the operators in detail in our upcoming articles. So, don't worry about them.) Step -2 Create observer that consumes data: In above code snippet observer is an observer that consumes the data emitted by the database observable. It processes the data received and also handles error inside it. Step-3 Manage concurrency : At the last step, we define our schedulers that manage the concurrency. subscribeOn(Schedulers.newThread()) tells database observable to run on background thread. observeOn(AndroidSchedulers.mainThread()) tells observer to run on the main thread. This is basic code for reactive programming.

What's a truth table?

A table that defines the results per operator rule a mathematical table used in logic—specifically in connection with Boolean algebra, boolean functions, and propositional calculus—which sets out the functional values of logical expressions on each of their functional arguments, that is, for each combination of values taken by their logical variables.

What is a transitive depedency?

A transitive dependency is a functional dependency which holds by virtue of transitivity among various software components. Computer programs In a computer program a direct dependency is functionality exported by a library, or API, or any software component that is referenced directly by the program itself. A transitive dependency is any dependency that is induced by the components that the program references directly. E.g. a call to a log() function will usually induce a transitive dependency to a library that manages the I/O to write the log message in a file. Dependencies and transitive dependencies can be resolved at different times, depending on how the computer program is assembled and/or executed: e.g. a compiler can have a link phase where the dependencies are resolved. Sometimes the build system even allows management of the transitive dependencies.[1] Similarly, when a computer uses services, a computer program can depend on a service that should be started before to execute the program. A transitive dependency in such case is any other service that the service we depend directly on depends on, e.g. a web browser depends on a Domain Name Resolution service to convert a web URL in an IP address; the DNS will depend on a networking service to access a remote name server. The Linux boot system systemd is based on a set of configurations that declare the dependencies of the modules to be started: at boot time systemd analyzes all the transitive dependencies to decide the execution order of each module to start. Database Management Systems Let A, B, and C designate three distinct (but not necessarily disjoint) sets of attributes of a relation. Suppose all three of the following conditions hold: A → B It is not the case that B → A B → C Then the functional dependency A → C (which follows from 1 and 3 by the axiom of transitivity) is a transitive dependency. In database normalization, one of the important features of third normal form is that it excludes certain types of transitive dependencies. E.F. Codd, the inventor of the relational model, introduced the concepts of transitive dependence and third normal form in 1971.[2] Example[edit] A transitive dependency occurs in the following relation: BookGenreAuthorAuthor NationalityTwenty Thousand Leagues Under the SeaScience FictionJules VerneFrenchJourney to the Center of the EarthScience FictionJules VerneFrenchLeaves of GrassPoetryWalt WhitmanAmericanAnna KareninaLiterary FictionLeo TolstoyRussianA ConfessionReligious AutobiographyLeo TolstoyRussian The functional dependency {Book} → {Author Nationality} applies; that is, if we know the book, we know the author's nationality. Furthermore: {Book} → {Author} {Author} does not → {Book} {Author} → {Author Nationality} Therefore {Book} → {Author Nationality} is a transitive dependency. Transitive dependency occurred because a non-key attribute (Author) was determining another non-key attribute (Author Nationality).

What is the biggest drawback about TCP?

Acknowledgements double the number of messages without transmitting any more data. Sometimes this overhead and the associated delays is not worth the improved robustness, especially when no delays is critical, such as in first-person shooter games.

What are the major embedded database systems?

Advantage Database Server from Sybase Inc. Berkeley DB from Oracle Corporation CSQL from csqlcache.com Extensible Storage Engine from Microsoft eXtremeDB from McObject Filemaker from Claris Firebird Embedded HSQLDB from HSQLDB.ORG, Informix Dynamic Server (IDS) from IBM InfinityDB from Boiler Bay Inc. InnoDB from Oracle Corporation InterBase (Both server and mobile friendly deeply embedded version) from Embarcadero Technologies Lightning Memory-Mapped Database (LMDB) from Symas Corp. Raima Database Manager from Raima solidDB SQLite SQL Server Compact from Microsoft Corporation Sophia Embeddable key-value storage

xxx

Connection pool From Wikipedia, the free encyclopedia Jump to navigationJump to search In software engineering, a connection pool is a cache of database connections maintained so that the connections can be reused when future requests to the database are required. Connection pools are used to enhance the performance of executing commands on a database. Opening and maintaining a database connection for each user, especially requests made to a dynamic database-driven website application, is costly and wastes resources. In connection pooling, after a connection is created, it is placed in the pool and it is used again so that a new connection does not have to be established. If all the connections are being used, a new connection is made and is added to the pool. Connection pooling also cuts down on the amount of time a user must wait to establish a connection to the database. Contents 1Applications 2Database support 3See also 4References 5Links Applications[edit] Web-based and enterprise applications use an application server to handle connection pooling. Dynamic web pages without connection pooling open connections to database services as required and close them when the page is done servicing a particular request. Pages that use connection pooling, on the other hand, maintain open connections in a pool. When the page requires access to the database, it simply uses an existing connection from the pool, and establishes a new connection only if no pooled connections are available. This reduces the overhead associated with connecting to the database to service individual requests. Local applications that need frequent access to databases can also benefit from connection pooling. Open connections can be maintained in local applications that don't need to service separate remote requests like application servers, but implementations of connection pooling can become complicated. A number of available libraries implement connection pooling and related SQL query pooling, simplifying the implementation of connection pools in database-intensive applications. Administrators can configure connection pools with restrictions on the numbers of minimum connections, maximum connections and idle connections to optimize the performance of pooling in specific problem contexts and in specific environments. Database support[edit] Connection pooling is supported by IBM DB2,[1] Microsoft SQL Server,[2] Oracle,[3] MySQL,[4] PostgreSQL,[5] and Neo4j.[6]

What are the core benefits of a PWA?

Core Progressive Web App checklist The Progressive Web App Checklist describes what makes an app installable and usable by all users, regardless of size or input type. Starts fast, stays fast Performance plays a significant role in the success of any online experience, because high performing sites engage and retain users better than poorly performing ones. Sites should focus on optimizing for user-centric performance metrics. Works in any browser Users can use any browser they choose to access your web app before it's installed. Responsive to any screen size Users can use your PWA on any screen size and all of the content is available at any viewport size. Provides a custom offline page When users are offline, keeping them in your PWA provides a more seamless experience than dropping back to the default browser offline page. Is installable Users who install or add apps to their device tend to engage with those apps more.

What is database connection pooling?

Database connection pooling is a method used to keep database connections open so they can be reused by others. Typically, opening a database connection is an expensive operation, especially if the database is remote. You have to open up network sessions, authenticate, have authorisation checked, and so on. Pooling keeps the connections active so that, when a connection is later requested, one of the active ones is used in preference to having to create another one. Refer to the following diagram for the next few paragraphs: +---------+ | | | Clients | +---------+ | | |-+ (1) +------+ (3) +----------+ | Clients | ===#===> | Open | =======> | RealOpen | | | | +------+ +----------+ +---------+ | ^ | | (2) | /------\ | | Pool | | \------/ (4) | ^ | | (5) | +-------+ (6) +-----------+ #===> | Close | ======> | RealClose | +-------+ +-----------+ In it's simplest form, it's just a similar API call (1) to an open-connection API call which is similar to the "real" one. This first checks the pool for a suitable connection (2) and, if one is available, that's given to the client. Otherwise a new one is created (3). A "suitable connection" is just one that already has access to the database using the correct information (such as database instance, credentials, and possibly other things). Similarly, there's a close API call (4) which doesn't actually call the real close-connection, rather it puts the connection into the pool (5) for later use. At some point, connections in the pool may be actually closed (6). That's a pretty simplistic explanation. Real implementations may be able to handle connections to multiple servers and multiple user accounts, they may pre-allocate some baseline of connections so some are ready immediately, and they may actually close old connections when the usage pattern quietens down.

What does DNS stand for in terms of the general system that translates IP addresses into human-readable domain names?

Domain Name System

What are some benefits of SOA?

Greater business agility; faster time to market: Reusability is key. The efficiency of assembling applications from reusable services - i.e. building blocks, rather than rewriting and reintegrating with every new development project, enables developers to build applications much more quickly in response to new business opportunities. The service oriented architectural approach supports scenarios for application integration, data integration, and service orchestration style automation of business processes or workflows. This speeds software design and software development by enabling developers to spend dramatically less time integrating and much more time focusing on delivering and improving their applications. Ability to leverage legacy functionality in new markets: A well-crafted SOA enables developers to easily take functionality 'locked' in one computing platform or environment and extend it to new environments and markets. For example, many companies have used SOA to expose functionality from mainframe-based financial systems to new web applications, enabling their customers to serve themselves to processes and information previously accessible only through direct interaction with the company's employees or business partners. Improved collaboration between business and IT: In an SOA, services can be defined in business terms (e.g., 'generate insurance quote' or 'calculate capital equipment ROI'). This enables business analysts to work more effectively with developers on important insights—such as the scope of a business process defined using services or the business implications of changing a process—that can lead to a better result.

What are HTTP/HTTPS protocols and HTTP verbs?

HTTP/HTTPS protocols: A fundamental knowledge of how the data is transferred using the transfer protocols will make you a better Node.js developer, a good understanding of how HTTP and HTTPS work is something every backend developer should understand well enough. GET: Used to retrieve a representation of a resource POST: Used to create new resources PUT: Used to update capabilities PATCH: Used to modify capabilities DELETE: Used to delete a resource identified by a URL OPTIONS: Request permitted communication option for a given URL or server

What is IOPS?

IOPS (Input/Output Operations Per Second, pronounced i-ops) is a common performance measurement used to benchmark computer storage devices like hard disk drives (HDD), solid state drives (SSD), and storage area networks (SAN).

What is aspect-oriented programming (AOP)?

In computing, aspect-oriented programming (AOP) is a programming paradigm that aims to increase modularity by allowing the separation of cross-cutting concerns. It does so by adding additional behavior to existing code (an advice) without modifying the code itself, instead separately specifying which code is modified via a "pointcut" specification, such as "log all function calls when the function's name begins with 'set'". This allows behaviors that are not central to the business logic (such as logging) to be added to a program without cluttering the code core to the functionality. AOP forms a basis for aspect-oriented software development. AOP includes programming methods and tools that support the modularization of concerns at the level of the source code, while "aspect-oriented software development" refers to a whole engineering discipline. Aspect-oriented programming entails breaking down program logic into distinct parts (so-called concerns, cohesive areas of functionality). Nearly all programming paradigms support some level of grouping and encapsulation of concerns into separate, independent entities by providing abstractions (e.g., functions, procedures, modules, classes, methods) that can be used for implementing, abstracting and composing these concerns. Some concerns "cut across" multiple abstractions in a program, and defy these forms of implementation. These concerns are called cross-cutting concerns or horizontal concerns. Logging exemplifies a crosscutting concern because a logging strategy necessarily affects every logged part of the system. Logging thereby crosscuts all logged classes and methods. All AOP implementations have some crosscutting expressions that encapsulate each concern in one place. The difference between implementations lies in the power, safety, and usability of the constructs provided. For example, interceptors that specify the methods to express a limited form of crosscutting, without much support for type-safety or debugging. AspectJ has a number of such expressions and encapsulates them in a special class, an aspect. For example, an aspect can alter the behavior of the base code (the non-aspect part of a program) by applying advice (additional behavior) at various join points (points in a program) specified in a quantification or query called a pointcut (that detects whether a given join point matches). An aspect can also make binary-compatible structural changes to other classes, like adding members or parents.

xxx

In computing, aspect-oriented programming (AOP) is a programming paradigm that aims to increase modularity by allowing the separation of cross-cutting concerns. It does so by adding additional behavior to existing code (an advice) without modifying the code itself, instead separately specifying which code is modified via a "pointcut" specification, such as "log all function calls when the function's name begins with 'set'". This allows behaviors that are not central to the business logic (such as logging) to be added to a program without cluttering the code core to the functionality. AOP forms a basis for aspect-oriented software development. AOP includes programming methods and tools that support the modularization of concerns at the level of the source code, while "aspect-oriented software development" refers to a whole engineering discipline. Aspect-oriented programming entails breaking down program logic into distinct parts (so-called concerns, cohesive areas of functionality). Nearly all programming paradigms support some level of grouping and encapsulation of concerns into separate, independent entities by providing abstractions (e.g., functions, procedures, modules, classes, methods) that can be used for implementing, abstracting and composing these concerns. Some concerns "cut across" multiple abstractions in a program, and defy these forms of implementation. These concerns are called cross-cutting concerns or horizontal concerns. Logging exemplifies a crosscutting concern because a logging strategy necessarily affects every logged part of the system. Logging thereby crosscuts all logged classes and methods. All AOP implementations have some crosscutting expressions that encapsulate each concern in one place. The difference between implementations lies in the power, safety, and usability of the constructs provided. For example, interceptors that specify the methods to express a limited form of crosscutting, without much support for type-safety or debugging. AspectJ has a number of such expressions and encapsulates them in a special class, an aspect. For example, an aspect can alter the behavior of the base code (the non-aspect part of a program) by applying advice (additional behavior) at various join points (points in a program) specified in a quantification or query called a pointcut (that detects whether a given join point matches). An aspect can also make binary-compatible structural changes to other classes, like adding members or parents.

What is the producer-consumer problem?

In computing, the producer-consumer problem (also known as the bounded-buffer problem) is a classic example of a multi-process synchronization problem. The problem describes two processes, the producer and the consumer, which share a common, fixed-size buffer used as a queue. The producer's job is to generate data, put it into the buffer, and start again. At the same time, the consumer is consuming the data (i.e. removing it from the buffer), one piece at a time. ProblemTo make sure that the producer won't try to add data into the buffer if it's full and that the consumer won't try to remove data from an empty buffer. SolutionThe producer is to either go to sleep or discard data if the buffer is full. The next time the consumer removes an item from the buffer, it notifies the producer, who starts to fill the buffer again. In the same way, the consumer can go to sleep if it finds the buffer to be empty. The next time the producer puts data into the buffer, it wakes up the sleeping consumer.An inadequate solution could result in a deadlock where both processes are waiting to be awakened.

What are the three key points of reactive programming?

RX = OBSERVABLE + OBSERVER + SCHEDULERS Observable: Observables are nothing but the data streams. Observables pack the data that can be passed around from one thread to another thread. They basically emit the data periodically or only once in their lifecycle based on their configurations. There are various operators that can help observers to emit some specific data based on certain events, but we will look into them in upcoming parts. For now, you can think observables as suppliers. They process and supply the data to other components. Observers: Observers consume the data stream emitted by the observable. Observers subscribe to the observable using subscribeOn() method to receive the data emitted by the observable. Whenever the observable emits the data all the registered observers receive the data in onNext() callback. Here they can perform various operations like parsing the JSON response or updating the UI. If there is an error thrown from observable, the observer will receive it in onError(). Schedulers: Remember that Rx is for asynchronous programming and we need thread management. There is where schedules come into the picture. Schedulers are the component in Rx that tells observable and observers, on which thread they should run. You can use observeOn() method to tell observers, on which thread you should observe. Also, you can use scheduleOn() to tell the observable, on which thread you should run. There are main default threads that are provided in RxJava like Schedulers.newThread(), which will create a new background that Schedulers.io() will execute on the code in an IO thread.

What are some alternatives to CGI?

Rack for Ruby on Rails, for example For each incoming HTTP request, a Web server creates a new CGI process for handling it and destroys the CGI process after the HTTP request has been handled. Creating and destroying a process can consume much more CPU and memory than the actual work of generating the output of the process, especially when the CGI program still needs to be interpreted by a virtual machine. For a high number of HTTP requests, the resulting workload can quickly overwhelm the Web server. The overhead involved in CGI process creation and destruction can be reduced by the following techniques: CGI programs precompiled to machine code, e.g. precompiled from C or C++ programs, rather than CGI programs interpreted by a virtual machine, e.g. Perl, PHP or Python programs. Web server extensions such as Apache modules (e.g. mod_perl, mod_php, mod_python), NSAPI plugins, and ISAPI plugins which allow long-running application processes handling more than one request and hosted within the Web server. Web 2.0 allows to transfer data from the client to the server without using HTML forms and without the user noticing.[14] FastCGI, SCGI, and AJP which allow long-running application processes handling more than one request hosted externally to the Web server. Each application process listens on a socket; the Web server handles an HTTP request and sends it via another protocol (FastCGI, SCGI or AJP) to the socket only for dynamic content, while static content are usually handled directly by the Web server. This approach needs less application processes so consumes less memory than the Web server extension approach. And unlike converting an application program to a Web server extension, FastCGI, SCGI, and AJP application programs remain independent of the Web server. Jakarta EE runs Jakarta Servlet applications in a Web container to serve dynamic content and optionally static content which replaces the overhead of creating and destroying processes with the much lower overhead of creating and destroying threads. It also exposes the programmer to the library that comes with Java SE on which the version of Jakarta EE in use is based. The optimal configuration for any Web application depends on application-specific details, amount of traffic, and complexity of the transaction; these tradeoffs need to be analyzed to determine the best implementation for a given task and time budget. Web frameworks offer an alternative to using CGI scripts to interact with user agents.

You could just enter the IP address 172.217.7.238 and render Google's website. What turns IP addresses into human-readable domain names, such as google.com?

The Domain Name System

xxx

Transport Layer Security, or TLS, is a widely adopted security protocol designed to facilitate privacy and data security for communications over the Internet. A primary use case of TLS is encrypting the communication between web applications and servers, such as web browsers loading a website.

What's the difference between UTF-8, UTF-16, and UTF-32?

Utf-8 and utf-16 both handle the same Unicode characters. They are both variable length encodings that require up to 32 bits per character. The difference is that Utf-8 encodes the common characters including English and numbers using 8-bits. Utf-16 uses at least 16-bits for every character. UTF-8 is most common on the web. UTF-16 is used by Java and Windows. UTF-8 and UTF-32 are used by Linux and various Unix systems. The conversions between all of them are algorithmically based, fast and lossless. This makes it easy to support data input or output in multiple formats, while using a particular UTF for internal storage or processing. UTF-16 uses a single 16-bit code unit to encode the most common 63K characters, and a pair of 16-bit code units, called surrogates, to encode the 1M less commonly used characters in Unicode. Originally, Unicode was designed as a pure 16-bit encoding, aimed at representing all modern scripts. (Ancient scripts were to be represented with private-use characters.) Over time, and especially after the addition of over 14,500 composite characters for compatibility with legacy sets, it became clear that 16-bits were not sufficient for the user community. Out of this arose UTF-16. [AF] Depending on the encoding form you choose (UTF-8, UTF-16, or UTF-32), each character will then be represented either as a sequence of one to four 8-bit bytes, one or two 16-bit code units, or a single 32-bit code unit.

What is a cooperative debugger?

Visual Studio for Mac uses the Mono Soft Debugger to debug managed (C# or F#) code in all Xamarin applications. The Mono Soft debugger is different from regular debuggers in that it is a cooperative debugger that is built into the Mono runtime; the generated code and Mono runtime cooperate with the IDE to provide a debugging experience. The Mono runtime exposes the debugging functionality through a wire protocol, which you can read more about in the Mono documentation. Hard debuggers, such as LLDB or GDB, control a program without the knowledge or cooperation from the debugged program, but can still be useful when debugging Xamarin applications in the event that you need to debug native iOS or Android code. For .NET Core and ASP.NET Core applications, Visual Studio for Mac uses the .NET Core debugger. This debugger is also a cooperative debugger and works with the .NET runtime.

What is short-circuiting in computing?

Where an expression is stopped being evaluated as soon as its outcome is determined. 1. With an or operator (eg., double pipes (||)), the expression is short-circuited when it evaluates to true. So for instance: if (a == b || c == d || e == f) { // Do something } If a == b is true, then c == d and e == f are never evaluated at all, because the expression's outcome has already been determined. 2. With an and operator (eg., double ampersand (&&)), the expression is short-circuited when it evaluates to false.

What is usually the determining factor for using UDP vs TCP for an application?

Whether the connection needs to be real-time (favors UDP) or not and whether or not every bit of the data being transferred is important (favors TCP) Generally, real-time connections like video streaming, VoIP, and some games will use UDP (User Datagram Protocol). UDP is used where real-time quick communication is crucial, and losing a few frames/packets in the process is acceptable. Non-real time communication most often uses TCP (Transmission control Protocol) as it is well established, provides packet ordering, retransmissions, and prevents packet loss. TCP is used where transferring every frame/packet is important. Netflix, Hulu, Youtube, etc. video streaming all use TCP and simply buffer a few seconds of content, instead of using UDP since the delay is not crucial and TCP transfers can be easily accomplished over HTTP and web browsers without the need for additional plugins and software. Generally, if the content will be made available later, it is most likely using TCP. Live TV streams and multicast video conferencing, on the other hand are usually over UDP. Such applications usually require their own protocol on top of UDP (often RTP/RTCP over UDP).

What is the basis for reactive programming?

Why do we need Asynchronous work? The simple answer is we want to improve the user experience. We want to make our application more responsive. We want to deliver a smooth user experience to our users without freezing the main thread, slowing them down and we don't want to provide the jenky performance to our users. To keep the main thread free we need to do a lot of heavy and time-consuming work we want to do in the background. We also want to do heavy work and complex calculations on our servers as mobile devices are not very powerful to do the heavy lifting. So we need asynchronous work for network operations. The evaluation matrix: Evaluation matrix Let's see what do we need from the library that handles all the asynchronous work. You can imagine below 4 points as the evaluation matrix for the asynchronous library. Explicit execution: If we start the execution of a bunch of work on a new thread, we should be able to control it. If you are going to perform some background task, you gather the information and prepare them. As soon as you are ready, you can kick-off the background task. Easy thread management: In asynchronous work, thread management is the key. We often need to update the UI on the main thread from the background thread in the middle of the task or at the end of the task. For that, we need to pass our work from one thread (background thread) to another thread (here main thread). So you should be able to switch the thread easily and pass the work to another thread when needed. Easily composable: Ideally, It would be great if we can create an asynchronous work and as we start spinning background thread, it just do it's work without depending any other thread (especially on UI thread) and stays independent from the other thread until it finishes its job. But in the real world, we need to update the UI, make database changes and many more things that make threading interdependent. So the asynchronous library should be easily composable and provide less room for the error. Minimum the side effects: While working with multiple threads, the other thread should experience minimum side effects from the other thread. That makes your code easily readable and understandable to a new person and it also makes error easily traceable.

The Server Stack (last three of four tiers)

all of the other tiers of the web application are in the settlement environment and taken together they are known as the server stack. There are at least directives that look to gather the there is the HDTV server it receives the request from the client and turn those panties the HGTV server. Dispatch request to the business to which is also known some time as an obligation Sarah and the obligations are in direct with the day data on the database server.