OpenLLM-France/wikimedia huggingface dataset:
# A-level Computing/CIE/Theory Fundamentals/Communication and Internet technologies

Client Side Server Model It is a distributed communication framework within a network amongst clients and servers.
Server: Is a powerful computer running a server program managing the requests of the client
Client Are PCs or workstations which users run application. Clients rely on servers for resources such as files and devices
Web servers
* Those server machines that provide services to other machines are servers
* Machines that are used to connect to them are clients
* A server machine may provide one or more service on the internet with a server software running on it to act as Web servers, email server, gaming serve or FTP.
Application of Client server model When a bank customer accesses online banking services with a web browser (the client), the client initiates a request to the bank's web server. The customer's login credentials may be stored in a database , and the web server accesses the database server as a client. An application sever interprets the returned data and provides the output to the web server. Finally the web server returns the result to the client web browser for display Software Utilization Software programs usually run off both the Server and the Client.
# A-level Computing/CIE/Theory Fundamentals/System software

* Specification link
* Operating system (OS)
* describe why a computer system requires an operating system
* explain the key management tasks carried out by the operating system
* Utility programs
* show an understanding of the need for typical utility software used by a PC computer system:
* disk formatter
* virus checker
* defragmenter software
* disk contents analysis/disk repair software
* file compression
* backup software
* Library programs
* show an understanding that software under development is often constructed using existing code from program libraries
* describe the benefits to the developer of software constructed using library files, including Dynamic Link Library (DLL) files
* draw on experience of the writing of programs which include library routines
* Language translators
* show an understanding of the need for:
* assembler software for the translation of an assembly language program
* a compiler for the translation of a high-level language program
* an interpreter for execution of a high-level language program
* explain the benefits and drawbacks of using either a compiler or interpreter
* show awareness that high-level language programs may be partially compiled and partially interpreted, such as Java
# A-level Computing/CIE/Further Problem Solving and Programming skills/Software development

* Specification link
* Stages of software development
* show understanding that software development consists of a number of stages, including requirement identification, design, coding, testing, documentation and maintenance
* show understanding that stages may overlap
* show understanding of the possible role of program generators and program libraries in the development process
* Testing
* show awareness of why errors occur
* show understanding of how testing can expose possible errors
* appreciate the significance of testing throughout software development
* show understanding of the methods of testing available: dry run, walkthrough, white-box, black-box, integration, alpha, beta, acceptance
* show understanding of the need for a test strategy and test plan and their likely contents
* choose appropriate test data (normal, abnormal and extreme/boundary) for a test plan
* Project management
* show understanding that large developments will involve teams
* show understanding of the need for project management
* show understanding of project planning techniques including the use of GANTT and Program Evaluation Review Technique (PERT) charts
* describe the information that GANTT and PERT charts provide
* construct and edit GANTT and PERT charts
# A Bit History of Internet

A Bit History of Internet: Client-server, Peer-to-peer, Cloud-computing and Internet-of-Things
* Preface
* Chapter 1 : Introduction
* Chapter 2 : Circuit switching vs packet switching
* Chapter 3 : Internet Edge
* Chapter 4 : Internet Core
* Chapter 5 : Client-Server
* Chapter 6 : Peer-to-peer
* Chapter 7 : Cloud-computing
* Chapter 8 : Internet-of-Things
* Chapter 9 : Conclusions
# A Beginner's Python Tutorial/Importing Modules

Last lesson we covered the killer topic of Classes. As you can remember, classes are neat combinations of variables and functions in a nice, neat package. Programming lingo calls this feature encapsulation, but regardless of what it is called, it's a really cool feature for keeping things together so the code can be used in many instances in lots of places. Of course, you've got to ask, "how do I get my classes to many places, in many programs?". The answer is to put them into a module, to be imported into other programs.

## Module? What's a Module?

A module is a Python file that (generally) has only definitions of variables, functions, and classes. For example, a module might look like this:

### Code Example 1 - moduletest.py

As you see, a module looks pretty much like your normal Python program.
So what do we do with a module? We import bits of it (or all of it) into other programs.
To import all the variables, functions and classes from moduletest.py into another program you are writing, we use the import operator. For example, to import moduletest.py into your main program, you would have this:

### Code Example 2 - mainprogram.py

This assumes that the module is in the same directory as mainprogram.py, or is a default module that comes with python. You leave out the '.py' at the end of the file - it is ignored. You normally put all import statements at the beginning of the python file, but technically they can be anywhere. In order to use the items of the module in your main program, you use the following:

### Code Example 3 - mainprogram.py continued

As you see, the modules that you import act very much like the classes we looked at last lesson - anything inside them must be preceded with modulename for it to work.

## More About Modules

Wish you could get rid of the modulename part that you have to put before every item you use from a module? No? Never? Well, I'll teach it to you anyway.
One way to avoid this hassle is to import only the wanted objects from the module. To do this, you use the from operator. You use it in the form of from modulename import itemname. Here is an example:

### Code Example 4 - importing individual objects

What is the point of this? Well, maybe you could use it to make your code a little more readable. If we get into heaps of modules inside modules, it could also remove that extra layer of crypticness.
If you wanted to, you could import everything from a module in this way by using from modulename import *. Of course, this can be troublesome if there are objects in your program with the same name as some items in the module. With large modules, this can easily happen, and can cause many a headache. A better way to do this would be to import a module in the normal way (without the from operator) and then assign items to a local name:

### Code Example 5 - mainprogram.py continued

This way, you can remove some crypticness, AND have all of the items from a certain module.
# ACE+TAO Opensource Programming Notes/Find a service on a naming server

After your naming service (and other services are running), the presence of your services can be tested for by trying the following:
This should then produce the following output:
Where your named services appear below the dashed line.
Now to actually connect the two applications. To make our previous example Naming Service aware, we need to add in the code to attach to the Naming Service, then, resolve our service from within that context. The following code, put in place of the code to bring in the IOR from the command line resolves a reference to the factory object using a human readable URL from the command line which is persistent from reboot to reboot. Here's the code snippet we'll be applying:
Note that the code is potentially all boiler plate which can be placed in a reusable function. The only two original parts of the code are the URL pulled in from the command line, and the string representing the name of or remote class, "Widgets".
In this example, everything is on one box, but in reality, none of these services need be running on the same hardware, they only need to be reachable by the indicated ports. Now, lets take a look at the client code.
# ACE+TAO Opensource Programming Notes/Create a notifier supplier

TAO's Notification service implements the OMG's specification for an extension to the event service. This new specification adds QOS and event filtering to the existing event model. For most applications, this infrastructure is a bit beyond what's needed, and for that reason, there aren't examples included in this book. If you wish to contribute a model, feel free.
# Preface

This section describes how to create a simple server similar to the quoter example in the TAO examples (ACE_wrappers/TAO/examples/Quoter). To get this to work, create the IDL file and run the tao_idl executable on that file. The command line looks like the following:
This generates a whole host of source files, only one or two of which you will be required to edit.

# Source file basic.idl

Running the tao_idl program against the following source, generates all the files you'll need to generate a simple server. The actual command line should be 'tao_idl -GI basic.idl' The command line option '-GI' is to generate the server related interface file listed below. All you need to do is to implement this file (i.e. fill out some of the empty member functions) and you're off to the races.

# Generated Server Interface Source

Don't forget to implement the server's interface (basicI.cpp). I usually make this a trivial call out to some other class where all the fun stuff is.
# ACE+TAO Opensource Programming Notes/Create an event supplier
## Discussion

The easiest of the two event sides to design is the supplier. In TAO 1.5 there are a few event examples. My favorite is the COSEC on the TAO site, which is similar to the example in the TAO Developer's Guide example. Unfortunately, in the examples on the TAO site, there are no comments. What follows is an example of a simple event supplier which sends an event every 6 seconds. To accomplish this, an ACE timer is set up (with associated handler/callback) which serves to send the event at the appointed time. Finally, the timer is inserted into an ACE reactor and told to "run" in open loop mode.
When reading the code, note at the top of main that connections are made to the orb, the naming service, and the event service. Then, quite a bit of boilerplate code related to creating connections to the event service can be found. The last line of this boilerplate code determines that the event channel will not care that consumers are disconnecting.

## Link Line Details

-lTAO_CosNaming -lTAO_CosEvent -lTAO_PortableServer -lTAO_AnyTypeCode -lTAO -lACE
# ACE+TAO Opensource Programming Notes/Create a notifier consumer

TAO's Notification service implements the OMG's specification for an extension to the event service. This new specification adds QOS and event filtering to the existing event model. For most applications, this infrastructure is a bit beyond what's needed, and for that reason, there aren't examples included in this book. If you wish to contribute a model, feel free.
# ACE+TAO Opensource Programming Notes/Create a process with both client and server

The model here is to set up a client like app, and at regular intervals, call the server code's handler on a once through (no loop) mode. Note the odd way this is crafted so that the poll function is called after the orb's process loop times-out. So, what can happen here is that the handler can call out to other ORBs and the run member of the local orb can act as a part time server. According to the TAO Developer's manual, the TCP stack will act as your cache while the poll function is doing its thing, thus, don't spend too much time in the poll function.
# ACE+TAO Opensource Programming Notes/Naming
## Installation

These days, the pre-compiled RPMs for redhat type servers (Fedora, RedHat, CentOS, etc.) are a pretty handy way to get your name server installed and running as a boot time service. That's certainly what I use on my laptop for testing, and at work on our servers. I don't know if someone has done something similar for the Microsoft platform, but I don't really consider this to be a popular choice for critical service platform due to their regular downtime requirements in an enterprise setting.
The very nice NameServer implementation provided for RedHat, and I assume other server vendors of the UNIX variety, has a config directory in /etc . The values in the config directory are easy to understand and edit, and there are mercifully few options to set. For instance, my opt file in /etc/tao, is the stock config file which came with the distro and is as follows:
Note that the endpoint corbaloc string doesn't have an address. This means it listens to all interfaces. If you wish to define a more restrictive listener, place your address after the double slashes, but before the colon. i.e.
# ACE+TAO Opensource Programming Notes/Create an event consumer
## Discussion

This event client is designed to accept the events from the previously defined event server. The main difference between the server, where you can simply stuff some message in a CORBA::Any object and sent it to the event dispatcher, the client needs to overload the POA_CosEventComm::PushConsumer class. Specifically, the push and disconnect members need to be overridden.

## eventsink.idl

Actually, this is a copy of eventsource.idl.

## Link Line Details

-lTAO_CosEvent_Skel -lTAO_CosEvent -lTAO_PortableServer -lTAO_CosNaming -lTAO_AnyTypeCode -lTAO -lACE
# ACE+TAO Opensource Programming Notes/Dealing with IORs

As described earlier, the raw IOR string for tying together client and server isn't the preferred method to getting the two sides to talk together. In a production environment, the usual method is to use a naming service. This serves both as a way to advertise a location for a service, and as a method to keep the effective IOR of the service constant. You might have noticed, had you played with the previous server example more than once that the IOR string tended to change. With this method, you can ensure both consistency and readability.
The infrastructure used by CORBA programs to perform such address registration and lookups is the naming service. For TAO, the naming service is started with several command line args. In the examples below, the arg "-ORBEndPoint" is used to define where the service will listen, and the arg "-ORBDaemon" is designed to force the daemon to actually act like a daemon. Oddly enough, none of the services (daemons) you will be compiling with TAO will actually act like daemons, unless you use this optional arg.
The endpoint is critical to running any TAO service or compiled client/server app. If you don't supply one, the default endpoint is the multicast endpoint. This default endpoint is described as being useful for apps where performance isn't an issue, or for testing. That being said, this author couldn't get the multicast IIOP endpoint to work on a stock Linux FC4 system, even though the Linux system swore that multicasting was up and running. I was able to verify the bug by running the multicast test app under the ACE framework test directory. To ensure that anyone reading this is able to get something up and running, we will therefore set up a client with the explicitly defined endpoint of "localhost".
There are two basic forms of this endpoint, there is the service advertising its services, and the client trying to find a service. To make this discussion intuitive, we will assume that in each example, a naming service server is running and reachable from your test box. To get the naming service started, try the following:
This should set up your naming service on port 12345 on the localhost interface. To test that this is up and working, try the following:
This should then produce the following output:
This shows that your naming service is up and running , but reporting no services yet. To see what a service looks like, try the following command to start the event service (which we will be using in later examples):
Now, when you run nslist again, you will see the following output:
Finally, we have a working set of servers we have connected together with IIOP endpoints. When you connect your clients and servers together, you will be using the same process... start the naming server, possibly the event service (or others) and then start in with your clients and servers. For linux, the people associated with the ACE+TAO project have provided RPM packages with script files designed to interract with linux's boot facilities which will start the naming service (and the others) automatically.
# ACE+TAO Opensource Programming Notes/Event
## Installation

These days, the pre-compiled RPMs for redhat type servers (Fedora, RedHat, CentOS, etc.) are a pretty handy way to get your name server installed and running as a boot time service. That's certainly what I use on my laptop for testing, and at work on our servers. I don't know if someone has done something similar for the Microsoft platform, but I don't really consider this to be a popular choice for critical service platform due to their regular downtime requirements in an enterprise setting.
The very nice CosEventServer implementation provided for RedHat, and I assume other server vendors of the UNIX variety, has a config directory in /etc . The values in the config directory are easy to understand and edit, and there are mercifully few options to set. For instance, my opt file in /etc/tao, is the stock config file which came with the distro and is as follows:
Note that the endpoint string doesn't have an address. This means it listens to all interfaces. If you wish to define a more restrictive listener, place your address after the double slashes, but before the colon. i.e.
# Accountancy/Accruals

An accrual is the effect of receiving goods or services before cash payment. This will most often result in a liability on the company's books, usually as a payable. Another type of accrual results from recognizing revenues before payment. Note this does not include unearned revenue, which is a deferral.
Sometimes a business uses a service (e.g. electricity) which it has not yet been invoiced for. The double entry for this is:
Journal - Page 1 :
| Date | Date | Description | Post Ref. | Dr | Cr |
| 2005 Feb | 28 | Electricity (Expense) | | 130 | |
| | | Unpaid electricity (Liability) | | | 130 |
Later when this bill gets paid
Journal - Page 1 :
| Date | Date | Description | Post Ref. | Dr | Cr |
| 2005 Mar | 12 | Unpaid electricity (Liability) | | 130 | |
| | | Cash (Asset) | | | 130 |
It is possible for an accrual to be made for telephone call charges in the period while the line rental (paid in advance) is a prepayment.
# Accountancy/Assets

An asset is an economic resource owned and controlled by an entity as a result of past events. and from which future economic benefits are expected to flow in the enterprise.
An asset can classified as: a. Current or non-current (see the definition below) b. Tangible or intangible (whether or not the asset has a physical existence).
The distinction between current and non-current assets is usually required in the presentation of the assets in the balance sheet.
Evidence of the existence of an asset is that an entity is exposed to the risks, as well as the rewards of ownership.
Importantly, the definition does not take into account legal ownership, but instead reflects substance. For example an asset leased under a contract which confers the significant risks and rewards on the lessee, is capitalized by the lessee despite the fact that legal ownership resides with the lessor.
Assets can be disclosed as current or non-current. A current asset is an asset that forms part of the operating cycle of an entity e.g. inventory (stock) or trade receivables (trade debtors). Alternatively, a current asset is an item which is not a component of operating activity, but which has a maturity of less than 12 months. Cash and cash equivalents are always classed as current assets.
Non-current assets are assets that do not fall under the category of current assets.
# Accountancy/Bookkeeping
## Basic Bookkeeping

An introduction to bookkeeping for community non-profit organizations.

### Quick Start

The purpose of this section is to introduce core concept: "always leave a papertrail", and give easy tips for a person who is immediately assuming financial duties, but hasn't yet read the rest of this document. Mention multi-signature bank accounts and other good habits?
So you've volunteered to be a treasurer for a community organization. Good for you! Now what? It can take time to take over from your predecessor and/or setup accounting practises for a new organization. In the mean time, your organization still needs to move forward. But here are some simple guidelines that will immediately help:
* get for receipts for everything. Write on the receipts memos of what it was for and who paid it (and if they need to be reimbursed)
* avoid cash, prefer cheques.
* if you have to accept cash, have two people count the money and sign a statement to the effect: "On this day, at this event, we counted $money in the cashbox. There was $float at the start of the event, so we collected $net total. (Person) is going to deposit $deposit in our bank account."
When in doubt, ask yourself: "if someone else looked at my records, would they understand how the money was spent?"

### Paper Trails

The purpose of this section is to introduce a simple single-entry accounting system, building on the previous section. Do this by showing ready-to-use examples of photocopiable forms, or showing how to use spreadsheets or chequebooks to track (and annotate) bank accounts. If possible, try and sneak in terminology and techniques from double-entry accounting.

## Cheque Book

(Using a cheque book to track and annotate bank account activities.)

## Event Cash Flow Sheets

(one 8.5x11 sheet of paper to record cash collection—e.g. from ticket sales. Have a chart to help cash counting, then a form for folk to sign off on the results. Organization-specific stuff would also be handy: e.g. new members.)

### Next Steps

The purpose of this section is to introduce double-entry accounting, building on the previous section. Show how to do this using low-tech supplies (eg. a dollar-store notebook). Lots of examples. Suggest spreadsheets.
(ideas: introduce "cash flow sheets" to replace the signed statements described above. Talk about banking. How to record transactions. Generally how to set up a simple bookkeeping system.. possibly including low-tech examples.)
# Accountancy/Capital and Reserves

Capital is an investment of money invested by the owners of a business with the intention of earning a return. Accounting usually treats the capital as money owned by the owners of the business, or money owed to the owners.
Reserves are funds set aside and may be specifically for a certain purpose or may be a general surplus funds. Various reserves such as Share Premium Reserves, Unappropriated Profit Reserves, etc. These reserves are usually created as excess funds and not to meet a liability (as in a provision).
# Accountancy/Cash flow statement

In financial accounting, a cash flow statement, also known as statement of cash flows, is a financial statement that shows how changes in balance sheet accounts and income affect cash and cash equivalents, and breaks the analysis down to operating, investing, and financing activities. Essentially, the cash flow statement is concerned with the flow of cash in and out of the business. As an analytical tool, the statement of cash flows is useful in determining the short-term viability of a company,