Malta offers pardon to suspected middleman in murder of reporter Daphne Caruana Galizia
by Stephen SoraceA man recently arrested in Malta after he claimed to know the identity of the mastermind who ordered the car-bombing murder of anti-corruption journalist Daphne Caruana Galizia in October 2017 was offered a presidential pardon, Maltese officials said Tuesday.
Prime Minister Joseph Muscat confirmed he made the offer on the condition that the man’s information about the assassination could be corroborated with evidence in court.
MURDERED REPORTER, DAPHNE CARUANA GALIZIA, MADE MANY ENEMIES
The man, who remains under police protection and has yet to be officially named, was arrested Thursday in a separate money-laundering case. He is alleged to have acted as a middleman between whoever ordered the death of Caruana Galizia and those who carried it out.
The man negotiated for the pardon to include his involvement in past crimes after telling investigators he feared for his safety if he were to be sentenced to prison, the Times of Malta reported.
His arrest is the latest development in the case. Three other men were arrested in December 2017 on suspicion of triggering the blast that killed Caruana Galizia. They are still awaiting trial.
MANUS ISLAND REFUGEE WHO WROTE BOOK VIA WHATSAPP LEAVES DETENTION CENTER AFTER SIX YEARS
The 53-year-old Caruana Galizia, known as a “one-woman WikiLeaks,” was killed in a car bomb outside her Bidnija home on Oct. 16, 2017. Prior to her death, she had reported to police that she was receiving threats.
The highly regarded journalist was known for going toe-to-toe with some of the country’s most popular political figures, accusing them of corruption and undermining the democratic institutions of the small European Union nation.
CLICK HERE FOR THE FOX NEWS APP
Her reporting included examining leaked documents in the Panama Papers financial scandal, which alleged that Muscat's wife Michelle and two government officials had offshore holdings in Panama.
Fox News' Lucia I. Suarez Sang and The Associated Press contributed to this report.


ANALYZE COMPRESSION
Performs compression analysis and produces a report with the suggested compression encoding for the tables analyzed. For each column, the report includes an estimate of the potential reduction in disk space compared to the current encoding.
Syntax
ANALYZE COMPRESSION [ [ table_name ] [ ( column_name [, ...] ) ] ] [COMPROWS numrows]
Parameters
- table_name
-
You can analyze compression for specific tables, including temporary tables. You can qualify the table with its schema name. You can optionally specify a table_name to analyze a single table. If you do not specify a table_name, all of the tables in the currently connected database are analyzed. You can't specify more than one table_name with a single ANALYZE COMPRESSION statement.
- column_name
-
If you specify a table_name, you can also specify one or more columns in the table (as a column-separated list within parentheses).
- COMPROWS
-
Number of rows to be used as the sample size for compression analysis. The analysis is run on rows from each data slice. For example, if you specify COMPROWS 1000000 (1,000,000) and the system contains 4 total slices, no more than 250,000 rows per slice are read and analyzed. If COMPROWS is not specified, the sample size defaults to 100,000 per slice. Values of COMPROWS lower than the default of 100,000 rows per slice are automatically upgraded to the default value. However, compression analysis doesn't produce recommendations if the amount of data in the table is insufficient to produce a meaningful sample. If the COMPROWS number is greater than the number of rows in the table, the ANALYZE COMPRESSION command still proceeds and runs the compression analysis against all of the available rows.
- numrows
-
Number of rows to be used as the sample size for compression analysis. The accepted range for numrows is a number between 1000 and<PHONE_NUMBER> (1,000,000,000).
Usage Notes
Run ANALYZE COMPRESSION to get recommendations for column encoding schemes, based on a sample of the table's contents. ANALYZE COMPRESSION is an advisory tool and doesn't modify the column encodings of the table. The suggested encoding can be applied by recreating the table, or creating a new table with the same schema. Recreating an uncompressed table with appropriate encoding schemes can significantly reduce its on-disk footprint, saving disk space and improving query performance for IO-bound workloads.
ANALYZE COMPRESSION doesn't consider Runlength Encoding encoding on any column that is designated as a SORTKEY because range-restricted scans might perform poorly when SORTKEY columns are compressed much more highly than other columns.
ANALYZE COMPRESSION acquires an exclusive table lock, which prevents concurrent reads and writes against the table. Only run the ANALYZE COMPRESSION command when the table is idle.
Examples
The following example shows the encoding and estimated percent reduction for the columns in the LISTING table only:
analyze compression listing; Table | Column | Encoding | Est_reduction_pct --------+----------------+----------+------------------ listing | listid | delta | 75.00 listing | sellerid | delta32k | 38.14 listing | eventid | delta32k | 5.88 listing | dateid | zstd | 31.73 listing | numtickets | zstd | 38.41 listing | priceperticket | zstd | 59.48 listing | totalprice | zstd | 37.90 listing | listtime | zstd | 13.39
The following example analyzes the QTYSOLD, COMMISSION, and SALETIME columns in the SALES table.
analyze compression sales(qtysold, commission, saletime); Table | Column | Encoding | Est_reduction_pct ------+------------+----------+------------------ sales | salesid | N/A | 0.00 sales | listid | N/A | 0.00 sales | sellerid | N/A | 0.00 sales | buyerid | N/A | 0.00 sales | eventid | N/A | 0.00 sales | dateid | N/A | 0.00 sales | qtysold | zstd | 67.14 sales | pricepaid | N/A | 0.00 sales | commission | zstd | 13.94 sales | saletime | zstd | 13.38


In this milestone, we’ll get acquainted with HTML and CSS, two of the key building blocks of every website. Using what we learn, we’ll build a very simple About page for you.
This milestone is a bit longer than the usual, and covers more ground than the usual, to help you get up and running. Rather than try to finish everything here in one sitting, find stopping points, and take your time to experiment with code samples provided here to really get a sense of how these key technologies (HTML and CSS) work. At the end of this page, you’ll walk away with a simple about page in no time.
Part 1: HTML Tags and Elements
Every webpage, including this one you’re reading right now, starts with some HTML code. HTML is what we call a markup language. It “marks up” text with additional meaning, like “this bit of text is a heading” or “this part of the text should be italicized.” We can also use HTML to add non-text elements like images, videos, and links to our pages as well as interactive things like inputs and buttons. For today, let’s start with simple text.
Everything is a tag
Here’s what a tag looks like in HTML.
|
|
This bit of code defines a short paragraph, using the
...

tag, which stands for a paragraph. Inside the paragraph, we have the text we want to be included in the paragraph. Let’s take note of a few things.
- The tag comes in a pair, an opening tag

, and a closing tag

. The pair of opening and closing tags tells us where the paragraph begins an ends, and everything in between is inside the tag. - The opening tag is a symbol for paragraph, surrounded by angle brackets
< >
. All tags look this way; the tag for the first-level heading, for example, is
...

. - The closing tag looks very similar, but has a forward-slash
/
before the symbol for the tag. This forward slash closes the tag. If you forget the slash, your code may break – if something seems off, check if you’ve closed your tags with/
properly.
Another thing to remember about HTML is that it treats all blank spaces the same. If we wrote, for example, this…
|
|
… this output the same result as the first example, because the large empty space in the middle gets smooshed into a single space in HTML. Try this for yourself in Codeframe, and see what kinds of spaces make a difference.
Here’s HTML for a heading, followed by two paragraphs.
|
|
There’s three tags here, including the

tag for a header. All three have closing tags, like they should. You’ll also notice the line numbers in front of the sample code – from here on, I’ll label each line of code with the line number, so we can refer to them easier. When you’re copying these samples to test them on your own, you should omit them.
A comment on HTML Comments
Consider this bit of HTML.
|
|
If you view this HTML in your editor, you’ll see that the first part, the part surrounded by
, doesn’t show up. This is a comment, and comments are ignored by browsers when they display your HTML on the page. All comments are surrounded by
, and can span multiple lines. Developers use comments like this to point out things in our code or add annotations or, well, comments, in our code, for other people to read. In this course, I’ll use them to point out things in the middle of our code blocks.
Tags can be inside other tags
HTML tags can be nested inside other tags to give additional structure to our text. If we wanted to have a bold bit of text inside a paragraph, for example, we can write
|
|
Here, we have a paragraph (

), that contains a
tag. The strong tag defines a bit of text that should be bold on the page. We can even nest further:
|
|
Here, we use the
tag, which represents some text to be italicized on the page. If you’ve written HTML before, you may have come across
and
tags, which bold and italicize as well. However,
and
are their modern equivalents; when you have a choice, bias for the modern replacements.
You may also notice that we’ve started indenting nested parts of our code further to the right. Because HTML doesn’t really care about “whitespace” or spaces in between tags and keywords, indentation is a matter of taste and personal preference. However, indenting different nested parts of your HTML code will help keep the structure of your page straight, as you build more complex sites. Get in the habit of indenting HTML code! It’ll be helpful in the long run.
Beware of common tag mistakes
There are two common mistakes I see from students new to HTML. The first is simply forgetting to close a tag. What’s wrong with this sample?
|
|
It’s almost right, but on close inspection you might see that the closing tag doesn’t actually close – the closing tag needs to be

, not

.
The second mistake has to do with the order of nested tags. Consider this example.
|
|
Surprisingly, almost all web browsers will take this HTML, and output exactly what you’d expect. But there’s a subtle mistake hiding here that browsers are forgiving us for ignoring. Since we opened the

tag first, then the
tag, we need to close the inner tag
first, then the

tag should be closed. The closing tags here are out of order. While this won’t cause immediate issues, it’s good to get in the habit of noticing these mistakes.
Tags with attributes
Sometimes, when we use an HTML tag, we also want to add some additional data about the tag. For example, when we mark up a bit of text saying “this is a link,” we’d want to define what the link leads to. We can add additional information like this to tags with attributes.
Let’s consider this link example. Links in HTML are marked with the
tag. (It’s represented by the letter “a,” apparently, because it stands for “anchor”.) We can add a link in the middle of our paragraph like this.
|
|
If you try this sample, you’ll notice that nothing actually happens (yet) when we click on the link. It looks like a link, but doesn’t go anywhere, because we haven’t told it where to go. How might we do that? We can add an attribute to our anchor tag, like this.
|
|
The href
stands for something roughly like “hyperlink reference”, and is an attribute we can add specifically to an
tag to denote where the link should point to. In this case, the href
attribute also has a value, which is the URL that the link should navigate the user to, when tapped. Attributes all live in side the opening tag of an element, and follows the tag name (a
in this case).
Attributes are everywhere. We use them to denote where image files are when we add images, what buttons should do, where forms should be sent, where download links are, and so on. We’ll encounter more and more of these use cases of HTML attributes as we delve deeper into HTML.
Part 2: Adding some color with CSS
As you’ve played around with your HTML code, you may have noticed that a webpage made of just HTML has a pretty boring, plain look. All of the text has a very Times New Roman feel to it, with set text sizes, set margins, and no sense of design. That’s because HTML focuses on one thing, and does just that one thing very well: structuring your webpage. It defines headings, paragraphs, buttons, and boxes, and that’s its only concern.
This is a common pattern in well-designed software: complex things are built up from smaller, simpler parts that to small things very well.
But that must mean there’s some other tool that handles makings things look a bit better! That other thing is CSS.
CSS, the Style Sheet
CSS is a different type of code (you may say a different language) that’s embedded inside our HTML pages to modify how our HTML pages look. There’s a few different ways to embed CSS code into our HTML pages, but we’re going to start with the simplest way, which is to put our CSS inside a
tag.
Let’s say we have this HTML…
|
|
… and we’d like to change some things about how the heading (

) looks. Specifically, we want to make it bright red, and we want to make it larger. We can do this with some CSS. Let’s try…
|
|
Adding these four lines of CSS changes the appearance of our HTML tags. Trying playing around with the values red
and 40px
. Try different colors, and different font sizes. Let’s break down this CSS code.
Selectors, properties, and values
Here’s our CSS from before.
|
|
Intuitively, here’s what this CSS code says:
For all

tags in this HTML page, set the (text) color to be “red”, and set the font size to be 40 pixels tall.
See how parts of the description correlate with the code? There’s a few parts to this short bit of CSS.
h1
is a selector. It “selects” the parts of the HTML document that the following rules should apply to.- The selector is followed by a block of code in curly braces
{...}
, which contains the CSS “declarations”, or rules, that apply to all

s. - Inside the curly braces, there are a list of declarations. Each declaration has a property, like
color
orfont-size
, and a value, likered
or40px
.
Let’s say we wanted to add another rule: we want all

s to have a yellow background. We can add another line of CSS, like this (I’ve temporarily omitted the HTML code here for brevity).
|
|
The background-color
property controls, yep, the background color of some HTML element.
An aside: CSS knows about a surprisingly large number of colors! There’s orangered
and aquamarine
and sandybrown
, all of which correspond to specific shades of color. You can find the full list of color labels here on MDN. If your color isn’t on there, you can also use a hexadecimal color value. If you don’t understand what that is, don’t worry about it just yet.
Styling different tags
Almost always, we’re not content with styling just one element on the page. In this example, we may want to also apply some styles to our paragraph tag,

. Adding new rules to new elements in CSS is straightforward: just add another section with the new selector.
|
|
These four new lines of code says this:
For all

tags in this HTML page, set the (text) color to be “blue”, and set the font style to be italic (italicize the text inside).
You’ll notice that the rules affect all

tags on the page, not just the first one. This is usually what we want, because that’ll keep our design consistent.
Fancy selectors: classes and children selectors
Consistency is usually what we want, but sometimes, we might want something to stick out. Let’s say we have three paragraphs.
|
|
But let’s say our second paragraph is super important – we want just the second paragraph to be bright orange. How can we select just the second paragraph? We might try to use the p
selector, but that’ll select all paragraphs. Instead, we can select specific elements on the page with classes.
A class is an attribute you can give to HTML elements (tags) that labels those specific elements. Classes can have any name you like, as long as it’s all one-word, no spaces. Let’s mark our second paragraph with a special
class.
|
|
Once we’ve marked the special paragraph with this class, we can select just this paragraph tag using the class in CSS. In CSS, we select by class name by using a dot .
before the class name, like this.
|
|
This CSS says,
Only select

tags that also have aspecial
class on them, and make those orange.
In this case, the only thing that has the special
class is a paragraph tag. So we can select with just the class name, without the tag name p
:
|
|
Classes are very powerful. We can have multiple classes, and we can apply classes to multiple different things. Take this more advanced example:
|
|
CSS gives us a huge amount of freedom as web designers and developers to express our creativity on the canvas of the web, and once you get a grasp of the basics from above, you can create lots of interesting designs.
We’ll explore more and more CSS properties as we move forward, so there’s no need to learn every property now. For this part, take the last sample above, open it in Codeframe (you can do so with the Try this → button), and try to make these changes:
- Change
color
property values for different elements on the page, and see if the results fit your expectations. - Take the last paragraph that begins with “He is also on twitter…", and make the font larger (24px) for just that paragraph. You may need to give that element a new class to do this.
- On the link element (

)…- By default, links appear blue (like on Google Search). Make the link here appear purple.
- Let’s make the link stand out a bit more. Make the text inside the link bolder, using just CSS. Search Google for the
font-weight
CSS property to help here.
Once you’ve explored CSS a bit here, we’re ready to dive into our first milestone project! Let’s build you an about-you page, completely from scratch, that you can put on the web.
Part 3: About page - Putting it all together
We’ll go about building your about page in two main steps, first writing the HTML, then adding some CSS.
The HTML
Your about page can include virtually anything you like, but should at least include…
- A first-level header (

) at the top of the page, that says “About [your name]” - An image, which will be your profile picture
- A tweet-sized, 1-2 sentence bio about you in a paragraph (

) or more - A couple of subsections, each section under an

(since they’re of lower importance the big main

section). What are you interested in? What are you working on? What music or films do you like? Make a list of some kind – we’ll show you how to do this down below.
Remember that the tag we use to include an image is
. The image tag also needs an href
attribute, which should be set equal to a link to the image.
Adding an image in HTML
There’s an HTML tag specifically designed to include images on a webpage, the
tag. The image tag looks like this in use.
|
|
There’s a few interesting things about the
tag.
- It doesn’t have a closing tag! There isn’t a

at the end. THis is because the image tag is one of several self-closing tags. Self closing tags exist because some tags can’t sensibly contain other tags. (What does it mean if an image tag has a paragraph tag inside?) A self-closing tag only needs the opening tag, and it closes automatically. You might notice the/>
at the end, which is another way to indicate that this tag is self-closing. - It has a
src
attribute, which is set to the URL of the image it should display. You can upload images to the web on services like Imgur and take their URL to embed your own images into your page. - It has an
alt
attribute, which is some textual description of the image. Thealt
text is used for when the image is not found (broken link), or when the reader of your page is using a screen reader.
Very often, the image you embed won’t be the size you want – it’ll be to big or too small. We can tweak that by setting a width or height with CSS on the image.
A brief primer on making a list
One new element that may be useful, if you’re making a list of activities, films, songs, or places, is the HTML tag for making lists,

. Let’s see how this works.
|
|
A list in HTML is actually made up of two different tags: the

tag, which stands for “unordered list”, and the

tag, which stands for “list item”. Why “unordered”, you ask? Well, an unordered list will produce a bulleted list. There’s also the

, which is an “ordered list”. Let’s see how that looks…
|
|
An

produces a list with numbers as labels, instead of bullets.
Here’s what my about page’s HTML looks like:
|
|
Adding styles with CSS
Now that you have some content for your about page, let’s make it look a bit prettier.
One change that you might be itching to make is to change the font on your page to something less reminiscent of a school report. We can control styles on the entire page by selecting the entire “body” of the page, like this:
|
|
What’s sans-serif
? “Serif” and “sans-serif” are two styles of fonts, or font families. You can read more about their difference here, but this should give your text a bit of a modern facelift.
If you included an image, you may also find that the image is too big or too small. You can adjust the size of the image by setting the width
and/or the height
CSS properties on the image tag, like this.
|
|
If you set both width and height, you may find that it distorts the image’s aspect ratio.
Another trick up CSS’s sleeve is curved corners. By default, all HTML elements are sharp rectangles. But we can adjust the roundedness of corners using the CSS border-radius
property, like this.
|
|
This may be useful if you want your picture or boxes to have a rounder, softer look. From here, you can add and apply styles to your HTML page to make it look the way you want. Here’s some CSS properties you might find useful as you explore ways to style your about page.
Adding borders around things
Here’s an example of a paragraph with a border around it:
This border was added with this CSS:
|
|
Experiment with different values for border thickness (border-width
), color, and style (you can pick between dotted
, dashed
, and solid
) to see what you like.
Padding inside borders and backgrounds
If you care about aesthetics, you might have felt that the bordered paragraph above feels a little off – there’s no margin between the paragraph and the border, so it all feels a little cramped. We can fix that by adding some padding
to the paragraph.
As we’ll learn more about later, in CSS, padding
represents the space between what’s inside the tag, and the border.
Let’s set padding to 8px
in this case:
|
|
This will add 8 pixels of breathing room around our paragraph, like this:
Curved corners with border-radius
We can add curved corners to our text boxes as well, like this:
This radius above is 10px wide.
|
|
Background color
We can add a background color with the background
or background-color
property (they’re synonymous for our purposes here).
This radius above is 10px wide.
|
|
Once you’ve arrived at an about page that fits your taste, please share it! Use that Preview button to send me a link to what you’re making! I’d love to hear from you and see where you are.
Milestone 1 recap
Congratulations on making it to the end of the first milestone! This was a long one, but we’ve learned a lot already that we’ll use and carry with us through the rest of the course. Specifically, we learned about…
- How HTML tags work to structure our webpage, and some common tags like

,

, and
- How tu write CSS to go along with your HTML, to change the look and feel of your HTML tags
- How to use selectors and CSS classes to write CSS rules for specific elements on the page
- Some common CSS properties, like color, background, border, and padding.
Next milestone, we’ll pick up where we left off and continue exploring HTML and CSS in more depth.


Currency Conversion Application
Forex Calculator
Australian Dollar
Bulgarian Lev
Brazilian Real
Canadan Dollar
Swiss Franc
Chinese Yuan
Czech Koruna
Danish Krone
EURO
British Pound
Hong Kong Dollar
Hungarian Forint
Indonesian Rupiah
Israeli New Shekel
Indian Rupee
Japanese Yen
South Korean Won
Mexican Peso
Malaysian Ringgit
Norwegian Krone
New Zealand Dollar
Philippine Peso
Polish Zloty
Romanian Leu
Russian Ruble
Swedish Krona
Singapore Dollar
Thai Baht
Turkish Lira
USA Dollar
South African Rand
Australian Dollar
Bulgarian Lev
Brazilian Real
Canadan Dollar
Swiss Franc
Chinese Yuan
Czech Koruna
Danish Krone
British Pound
Hong Kong Dollar
Hungarian Forint
Indonesian Rupiah
Israeli New Shekel
Indian Rupee
Japanese Yen
South Korean Won
Mexican Peso
Malaysian Ringgit
Norwegian Krone
New Zealand Dollar
Philippine Peso
Polish Zloty
Romanian Leu
Russian Ruble
Swedish Krona
Singapore Dollar
Thai Baht
Turkish Lira
USA Dollar
South African Rand
Currency Rates to Euro Base Rate
Currency
Forex Code & Rate


When teaching computer science it can be easy to focus on details and lose sight of the bigger picture; this is particularly concerning with new pre-tertiary curricula being adopted in many countries, as teachers grapple with a bewildering array of topics to teach. Why do students need to know how to "code?" Why do we teach them how to work with binary numbers? What's the purpose of learning selection sort and quicksort? This document presents a list of 10 "big ideas" of computer science that have been distilled based on input from curriculum designers and computer science education experts around the world. Although the 10 ideas have been numbered to help us talk about them this does not indicate an order
Tim Bell, University of Canterbury, NZ
Paul Tymann, Rochester Institute of Technology, New York, USA
Yehudai, Tel Aviv University, Israel
A huge variety of information is stored as data on digital devices, and shared between them; the data may be as simple as the number of steps counted on a fitness tracker, or as complex as the details of every transaction going through an international organisation; it includes text, images, video, sound and scientific readings. The remarkable thing is that all of this information is reduced to digits (that's the fundamental thing that makes digital devices so useful). Digital representations lead to versatile devices because the same hardware can be used for quite different purposes: a smartphone can play music, take photos, send email and show videos, because all these things are represented as digits, which are easily stored, copied, manipulated and transmitted on the same hardware. This is in contrast to non-digital (i.e. analogue) devices, which by nature are specialised (phones connect to a phone line, a TV gets a signal from a TV aerial, music is played from a vinyl disc, and video is recorded on videotape). Digital data can also be shared without loss of quality, whereas analogue devices tend to reduce the quality if the material is copied or re-transmitted. Digging deeper: ● The digits are usually represented in binary, although the key is that they are discrete (not continuous) values. Traditionally these binary digits are written as 0 and 1, but in practice they use electric, magnetic, audio and optical representations. The choice of just two different digits is essentially an engineering tradeoff of cost and complexity (it's easier to distinguish between two different values than, say, 10 different levels), but it relates to the idea that the simplest possible number system is binary (Claude Shannon pointed this out, and suggested that "bit" might also stand for Basic Indissoluble uniT). The basic circuitry that manipulates the bits is based on Boolean logic, and the simplicity of having only two values makes reliable electronic circuitry relatively inexpensive to construct. ● Despite a bit being so simple, you need relatively few digits (bits) to represent very large numbers e.g. you can write a number larger than the number of atoms in the universe in using a few hundred bits. ● Although the digits are represented physically, the scale is very different to what we are used to in the physical world; a Blu-Ray disk holds about 200 billion binary digits in a few square centimeters, and a Fibre-optic cable can transmit a similar number of bits in seconds, at the speed of light. This means that it is feasible to store and share useful amounts of all kinds of data on mobile or desktop devices, and for mass storage there are also very large general purpose systems (servers and cloud storage) that store data for multiple users and purposes. ● Traditionally data is converted to a series of binary digits (bits) and represented using electrical, magnetic, audio, or optical representations. Different approaches to representing data as bits can improve how efficiently and effectively it can be stored, transmitted, accessed, and manipulated. For example, compression methods are used to reduce the size of a file, and encryption can be used to prevent others from discovering the contents of the file, whether they are intruding onto your computer, or eavesdropping on data that you are sending through a wired or wireless network. Nevertheless, compressed and encrypted data is still stored as digits. ● Techniques for manipulating information are at the core of the discipline, and hence processing digital representations is fundamental, whether it is changing the brightness of a photo or adding up the bill on a cash register. ● Within a programming language the representations of stored information is articulated as data types (e.g. integers, characters, strings of characters, and composite types that lead to more complex structures). They are all bits, but the programmer can decide that the purpose of the bits are in each situation. This also applies to files; in a text file the bits are interpreted as textual characters, while in a spreadsheet file most of the bits may be interpreted as numbers, and in an image they might be interpreted as representing colours. ● Programs themselves are stored as data; the same hardware that stores music or video is also used to store the app (software) that can display those files. ● Values in the physical world are analogue, which means that there are no discrete steps in values (e.g. for any distance or time, there is always a distance or time that is a little smaller, setting aside questions around quantum mechanics!). In contrast, digital devices represent the physical world as discrete values (such as treating a photo as a few million discrete pixels, or a sound as sound pressures selected from a limited range of values). The digitisation of analogue measurements is an example of abstracting away detail for the sake of simplifying the representation. The more detail that is removed, the simpler it is to store and process, but eventually the abstract becomes an oversimplification. The goal is to remove detail that is irrelevant to the computation or beyond human perception, to avoid using too many bits to store detail that won't be needed. The digital representation will nevertheless not be an exact version of the original. ● Computers move digits (bits) around through various hierarchies of memory, from very fast cache memory to off-site data warehouses. ● Digital representations must be invented for each type of data we represent. Creating new representations (such as new alphabets or languages) gives us the opportunity to think about how new writing methods are developed, and how they can be designed for different situations, giving some insight into the way that languages and alphabets have developed over the history of human-kind. ● Storing data requires physical matter (such as transistors), and transmitting it requires energy (such as light over a fibre optic cable). This can be done very efficiently in modern systems, but limitations in data storage capacity and transmission speeds exist because of the physical process involved. ● Computers exist that use a model other than simple digital representation (e.g. analogue computers and quantum computers), but currently digital devices (primarily using binary-based representations) dominate the devices that we use because this is currently the best engineering tradeoff for the various desired attributes such as economy, power consumption, size, reliability and versatility.
An algorithm is a well defined process that acts on data to solve some problem i.e. to achieve a result, such as finding the shortest route on a map, matching two strands of DNA, or changing the brightness of a photo. An algorithm can only include steps that a conventional computer could do; for example, you couldn't just put in a step that says "find the most efficient solution". Remarkably, the full power of a conventional digital device can be realised by an algorithm using just three structures to control program flow: sequencing (putting instructions one after the other), selection (choosing which part of the algorithm to execute based on some values, usually using an "if" statement), and iteration (repeating part of the algorithm with a loop). Apart from these three basic types of instruction, a computer is able to read in information (input), give out information (output) and store data to use later on. These basic components can be used to define every algorithm, as they define exactly what can (and can't) be done on conventional devices. Digging deeper: ● Algorithms can be expressed as a static (finite) representation that describes a dynamic (potentially infinite) process. ● The "conventional" computer referred to here is the kind of processor found in typical digital devices, including personal computers, smartphones, supercomputers, cloud services, internet devices, and digital watches. Examples of unconventional computers would be quantum computers and analogue computers. ● The kind of algorithm that can be used in a given situation depends on the way that data is stored and organised (the organisation is referred to as data structures). For example, finding the smallest file in a list sorted in ascending order of size has a simple algorithm (just pick the first file!), while finding the smallest file in a huge disorganised list requires a different algorithm. There is a close relationship between algorithms and data; designing computer systems often involves tackling the tradeoff between efficient data storage and efficient algorithms to process the data, so it is therefore very important to be aware of the advantages and disadvantages of different ways of storing data. ● The term "computational problem", "algorithmic problem", or simply "problem" in this context is often used to refer to the task that needs to be computed e.g. searching for a word, sorting values into order, finding the shortest route on a map, or finding a face in a photo. These kinds of problems are different from, say, a maths problem, where students might be expected to find a single correct solution. A computational problem can have several correct solutions (algorithms), and an algorithm is a general process for solving that type of problem. For example, if the problem is how to search for any given word in any given document, there are several possible algorithms (e.g. a sequential search comparing every word; or sorting the words into alphabetical order and then searching the alphabetical list); these computational solutions contrast with a specific outcome, such as "where is the word 'score' in the Gettysburg address?", which has the simple answer that it is the second word. ● Algorithms should solve for all possible inputs that might be given in the future (such as finding the high score in any list of scores); this contrasts with other human problem solving that solves for just one instance at a time e.g. design a bridge for a particular river crossing. ● The model for a conventional device (using sequence, selection, iteration, input, output and storage) goes back to the first electronic computers, and is based on work done by Alan Turing and Alonzo Church; conventional devices and programming languages that meet these criteria are often (loosely) referred to as "Turing-complete". Because all conventional digital devices that we work with meet these criteria, it means that designing algorithms using this model has very broad applicability. The concept is explored further by Guzdial here https://computinged.wordpress.com/2012/05/24/defining-what-does-it-mean-to-understa nd-computing/. Turing's model can also be expressed using an equivalent approach called recursion, which can make an algorithm easier to reason about how it works. ● Algorithm correctness is important - we need to be sure that it achieves exactly what we expect it to achieve. This includes heuristics (near enough solutions that may not be perfect, but can be computed faster than the optimal solution); heuristics can be considered to be the correct solution if the desire is for a solution that is fast enough and near enough to the best possible solution. ● The interaction of algorithms with data is crucial; we can choose between various ways to arrange data in computer storage (through "data structures"), which affect how quickly it can be accessed. Whenever the form of data is changed, there is typically a tradeoff between time and space e.g. a search data structure such as a "hash table" is faster than an unstructured list, but wastes space. Data structures can give faster access to data for purposes like searching for information, finding patterns, and calculating paths through maps. There are many kinds of data structures used on computers, ranging from variations on lists, to trees and "graphs", which can represent general networks such as road maps. The relationship between data structures and algorithms is seen, for example, between searching and lists; a sorted list can be searched more efficiently than an unsorted list because it makes a better algorithm possible, but it requires more computation in advance to ensure the list is in sorted order. ● The data can also have the fundamental bit-level structure of how it is stored changed to make it take less space (compression), to make it meaningless to eavesdroppers (encryption) or to make it useful even if a few of the bits get messed up (error control). This also presents tradeoffs; for example, a JPEG file is smaller than a raw image file, but requires processing to make it smaller, and there will be a tradeoff in quality. The technical word for changing the bit-level representation of data is "coding", although the meaning in this context is quite different to the meaning of "coding" in the context of programming. Coding changes the form of representation for encryption, compression or error control to better suit how we wish to use it. ○ Encryption can allow us to transmit data while someone observes all transmissions (including setting up the encryption keys), yet the eavesdropper is still unable to decode anything from the data. This enables a secure connection to be set up with a bank or online shop. ○ Compression has the potential to reduce the size of files so they use less storage and are transmitted faster; some methods however can expand the files rather than compress them, and it is impossible to achieve infinite compression. Compression is particularly important for large media files such as photos (e.g. JPEG, GIF, PNG), video (e.g. MPEG) and audio (e.g. MP3). ○ Error control enables us to detect when data has been corrupted, to any level of confidence required. All data stored long-term on disks and flash memory, and all data sent over wireless, wired and fibre networks has error control added to it to make sure that the user doesn't accidentally end up working with incorrect data. ● Many algorithms rely on decomposition using "divide and conquer" techniques, where the problem being solved is being reduced in size until it is small enough to deal with easily (e.g. sorting one item into alphabetical order is trivial!) A key idea here is recursion - expressing a problem as the combination of smaller problems, which themselves can be broken into smaller problems, and so on until you reach a trivial "base case". The problem might have millions of items in it to process (such as searching for a word in a list of a billion words), but the base case typically has only one, or even zero, items in it (such as searching for a word in a list of just one word).
The main resources that an algorithm uses are time and space (memory). Time is a key factor because slow programs are annoying to users, and if a program is going to take decades to complete a calculation, it's better to work that out before you go to the trouble of implementing it! Using an unnecessarily inefficient algorithm will also lead to devices wasting power or needing cooling, which have an environmental impact; or it could make the battery on a device go flat too quickly. Some algorithms also need a lot of spare memory or storage while they are running. This may make the algorithm infeasible in some cases, while in other cases it might be an excellent tradeoff if the algorithm is faster. The time taken to solve a problem with an algorithm (and therefore programs that run the algorithm) isn't necessarily proportional to the size of the input; sometimes it's better than that, and sometimes it's a (lot) worse. The time taken by an algorithm is usually estimated based on the size of the input (such as the number of items being searched through, the number of streets in a map, or the number of pixels in an image). It's important to at least estimate the speed of an algorithm before implementing it, as it might be very sensitive to the size of the input; perhaps a program works satisfactorily in tests, but with a larger input it might take a lot longer. Digging deeper: ● There can be many different algorithms for solving the same problem, but some are more efficient than others (for example, you could look for a book in a library by starting at the first shelf and checking every book, but it's better to take advantage of the order that the books have been shelved). ● The time taken by an algorithm on particular input is often measured as a function of the amount of input to the algorithm. Sometimes the time taken by an algorithm is proportional to the amount of data (given twice as much data, such an algorithm would take roughly twice as long to process it), but very often the time taken is not proportional. Many algorithms take more time than would be predicted from an assumption of taking proportional time (for example, sorting algorithms generally take more than twice as long to sort twice as much data); there are also some algorithms (such as binary search and hashing) that hardly take any extra time even to process a problem that is 10 times as big. Some algorithms become completely infeasible if even a little more data is added to the problem because they require exponential time in the amount of data they are processing; for example, there are algorithms where adding one extra item of data can double the processing time. Such problems that don't have feasible algorithms are referred to as "intractable" (see the next big idea). ● The rate of growth of the resources needed by algorithm is referred to as its complexity. Complexity measures are not usually made precisely, since the time taken will depend on the particular computer and other details, so instead they consider the rate of growth; for example, the notation O(n) is used to indicate that an algorithm solving a problem of size n takes and amount of time proportional to n, whereas O(n 2 ) indicates that it will take time proportional to the square of the amount of input (doubling the amount of input will take approximately 4 times as long to process). ● Choosing the wrong algorithm for a situation can lead to unnecessary computation, which uses power (e.g. battery life on a portable device, or expensive energy in a large data centre); this in turn can have environmental impacts. ● It is possible to quantify a lower bound on the amount of time that a problem may take to solve even if we don't have an algorithm in mind; as a trivial example, for most problems, if a program is processing n values, then it at least needs to take the time to read in all n values. An algorithm gives an upper bound for how long the problem will take to solve (since it solves the problem, but we might not yet know if a faster algorithm exists). For some problems we have a large gap between the known upper and lower bounds, while for others we know what the best possible algorithm is. ● Computer science routinely deals with very large and very small quantities. Online systems can deal with billions of customers or transactions, cheap cameras capture millions of pixels in a fraction of a second, personal computers store billions of binary digits, data usually travels at the speed of light, and a step in a computer instruction happens in a billionth of a second, yet some algorithms can take billions of years to complete. It is important to be able to evaluate these situations, as sometimes they work in our favour (e.g. a code that takes billions of years to crack) and sometimes against us (e.g. an image enhancement algorithm that takes hours to complete).
There are some computational problems that we can prove will never have programs written to solve them (these problems are not computable). For example, we can prove that no one will ever be able to write a general app that can vet another app to tell you if it will freeze your smartphone (more formally known as the halting problem). In addition to non-computable problems, there are many practical problems for which all known algorithms to find optimal solution are “intractable”, which means that no machine exists that has the resources required to execute the algorithm once the size of the input gets fairly large. For these problems we need to consider heuristics (that is, find an approximate solution) rather than pursue optimal solutions that could potentially take billions of years to evaluate on the fastest computer. Some problems have mathematical proofs that they are intractable, but there are many problems for which we haven't found an algorithm that runs in a reasonable amount of time, despite decades of research; yet we also haven't proved that the algorithm can't exist. Resolving this issue is widely regarded as one of the biggest questions in computer science! Digging deeper ● A consequence of these ideas is that the idea that "computers can calculate anything given the right program" is incorrect. The limits of what can be computed may change if new types of computing become common (e.g. quantum computing), but with the devices that have been in use since the dawn of electronic computers, there are definitely things that can't be done. ● Another example of a non-computable problem is the "line of code" problem. If you write a large program, you might want to know for a particular line of code in the program if it ever gets executed, but no-one can ever write a program that reads in another program and tells you if a particular line will be executed. Of course, it can be done in some special cases, but no general program can be written to achieve this. Another program that can't be written is one that is given two other programs, and decides if they always produce exactly the same output if they are given the same input. ● Problems for which we have only algorithms that take an exponential amount of time (or space) as the size of the input increases are generally regarded as intractable as the time needed can blow out to billions of years very quickly. Such algorithms amount to trying out every possible answer to find the best. (Exponential time typically means that to process n items of input, the time taken will be proportional to 2 n or worse, which doubles each time just one item gets added. This grows extremely large very quickly - for example, adding 10 more items will multiply the time by more than 1000.) There are examples where this is frustrating (e.g. finding the perfect route for a courier to drop off parcels is intractable; we can find routes that are probably perfect or nearly perfect, but it would take too long to be sure we have the best possible route, and therefore we may be wasting fuel and time); on the other hand, this negative situation applies to cryptography, where cracking the codes that are in widespread use is intractable, and the lack of algorithms to do this makes secure communication and commerce possible online. ● For some problems we know the optimal (fastest) algorithm for solving them because we can prove it can't be done in fewer steps, but for others we haven't discovered tractable algorithms yet, and in some cases we don't even know whether or not tractable algorithms exist. One of the biggest open questions in computer science, called the P vs. NP problem, is related to intractable problems. There are two interesting variations of intractable problems: design an algorithm that produces a solution to the problem, or design an algorithm to check that a given solution is correct. For this huge family of thousands of important problems (e.g. timetabling, route planning, vehicle loading, and DNA matching), we have efficient algorithms for checking if a given solution is correct, but we do not know if an efficient algorithm for finding a solution will ever be discovered. As an example, consider the bin packing problem, in which objects of different sizes have to be packed into a finite number of containers, each of a fixed capacity. If we are given a proposed packing (which items are to be packed into each bin), checking that this is a valid packing is an easy task that can be done efficiently - you just need to check that no container is too full. But we do not know of any efficient algorithm that will always decide if the given objects can be packed in a given number of bins. The remarkable fact is that if an efficient algorithm is found for any one of these problems, then all the other problems will also have an efficient algorithm, and similarly if we show that no efficient algorithm exists for any one of them, than all of them are intractable. ● Despite not being able to find efficient algorithms to find optimal solutions, many heuristics (algorithms that give near-optimal solutions) have been developed, and some are known to come very close to the optimal solution, which means that in many practical situations it is better to focus on improving heuristics, and not worry too much that the result might be very slightly short of optimal.
Programming involves taking algorithms (which might exist only in the programmer's head, or may have been designed by a team of people) and turning them into program instructions that can be executed by a computer. Program instructions are written in a programming language which is precisely defined. These instructions manipulate data on the computer, so the form and meaning of the data is dictated by the program. Because the capabilities needed to fully control a general purpose computer (which covers most digital devices) can be defined by six properties, consisting of three control structures (often expressed as sequence, selection, iteration), and three ways to deal with data (input, output and storage), these properties are also the key elements of writing programs. Consequently, any programming language that has all of these elements can be used to write any computation that any other full programming language could be used for, and the differences between languages is largely to do with how well they suit a particular situation (e.g. for processing files, running on a smartphone, teaching programming, or running an enterprise system). Digging deeper: ● The six properties are the same as the structures used to define algorithms: ○ Sequence: specifying instructions to happen one after the other ○ Selection: choosing between two different sets of instructions (commonly an "if" statement) ○ Iteration: repeating a set of instructions (loops) ○ Input: reading in data from outside the program, which could be from a keyboard, pointing device, a file, a network, or even another program ○ Output: getting data out of the program, which could be to a screen, through a network, into a file, or to another program ○ Storage: also known as memory; being able to store data for use later in the program (typically in variables) or long-term storage such as files on a disk. ● This means that if a student has learned enough programming to include the six properties needed, then in principle they have the tools to program anything that can be computed. A consequence is that even "simple" languages like Scratch are actually just as capable as the most advanced languages if the programmer has learned the right parts of the language; they just might take more work to achieve the same thing, and have less suitable input and output formats. ● The six properties derive from the idea of a universal computing machine articulated by Alan Turing, and computers and languages with this capability are often (slightly loosely) referred to as a Turing-complete system. The modern digital devices that we work with (from small portable devices, to large "cloud" computing systems) and commonly used language both meet these requirements, and are no more powerful than Turing's universal machine, so they are fundamental in defining what computers can and can't do. ● There are always different ways to implement a program and store the data it works with; this means that programming is an act of creativity, and there is no single way of implementing a program for a particular situation. ● Getting programs to work correctly isn't just a matter of "coding" them; developing programs involves designing the structures, testing them and debugging the software, and these are all important skills for a programmer to have. ● A programming language (such as Python, Scratch, Java, JavaScript or Basic) is designed for a particular purpose, and has a formal description of what can and can't appear in a program (syntax), as well as what each command does (semantics). Defining these rules is the domain of formal languages, which provides tools for concisely specifying how a given programming language works. ● Although all current devices and languages are (essentially) Turing-complete, there are more powerful models of computation, such as non-deterministic systems and quantum computing, but building them is challenging, and commonly used devices remain Turing complete (so far!). ● There are also less powerful models of computation (such as Regular Languages and grammars) that are easier to use and do the job for some purposes; these are sometimes used as a part of a program for doing some simple tasks such as checking the format of input values, and also checking for some of the syntax errors in computer programs! ● Computer programs are stored on computers in the same way as data is, represented using these zeros and ones, including the "source" code that humans write, and the machine code that actually runs on a digital device. This means that programs are also stored as data, and that computer programs are used to manipulate other computer programs in the same way that they manipulate data; the most common form of this is compilers and interpreters that allow us to write programs in high level language and have them run on a computer that uses a low level language. It also means that a digital device is very flexible; the program is just data that can be updated or replaced easily, so the same device can be used as a video player, a burglar alarm, a medical monitor, and a game system. 6. Digital systems a
This is the driver for all the ideas above; digital devices must be fast, reliable and match a need appropriately if people are to use them, and because they are designed by people, the process for designing them needs to enable the developers to efficiently turn creative ideas into working products. This means that there are (at least) three broad areas concerned with human factors: ● human computer interaction, which is about creating interfaces that are easy to use in the situation they are intended for, ● software engineering, which is concerned with enabling organisations to develop software on a large scale (potentially with thousands of people contributing to it), and at the same time making sure that the product meets the needs of the user, is reliable, does what is intended, and is completed in a timely fashion, and ● ethics, which considers the impact of a new technology on humans, the responsibilities of those who work on it, and possibly even whether or not we should construct it. All of these concerns require some understanding of human behavior (psychology), interaction (sociology), and capability (physiology). Digging deeper: ○ Frustrating and inaccessable user interfaces are far too common, and "easy to use" systems that delight users sell for a premium. Designing good interfaces builds on all the big ideas in this document to make software work quickly and reliably, and also builds on the human sciences to make sure the final product matches the way people work. ○ Although it might seem that programs are written for machines, the text of programs themselves is written by humans, for humans - most programs will be read by someone else later, and they need to be written in a way that they can be understood quickly and unambiguously (e.g. with meaningful variable names and comments). Knuth's "Literate programming" is based on this idea: "Instead of imagining that our main task is to instruct a computer what to do, let us concentrate rather on explaining to human beings what we want a computer to do." (Knuth, 1984); and Abelson & Sussman (1996) wrote: "Programs must be written for people to read, and only incidentally for machines to execute." ○ This also means that we highly value processes that enable people to collaborate efficiently and effectively in teams to produce software that works well for the end users; this is the realm of software engineering, and involves many techniques around working on large projects in teams to produce quality software. ○ The processes used to build digital systems need to assure us that the product will work appropriately. This involves human processes itself; ensuring that a program is reliable requires designing thorough tests for it, and tracking down any bugs can require a lot of skill. Even then, a test might show the presence of bugs, but if software passes all tests, that doesn't necessarily mean that it is bug-free (this was articulated by E.W. Dijkstra). ○ Decomposition is a general tool in computer science that breaks a large task or object into smaller components that can be dealt with without the distraction of the whole being visible while working on a small part. Building large software systems (software engineering) relies heavily on decomposing the task, as a large system needs to be built by multiple people working on parts of a system. This is sometimes seen as a "stack" of sub-systems; for example, communication systems have layers from the physical specifications through to protocols the programs can interface directly to regardless of the network being used (such as file transfer and email); web programmers use a stack of systems that simplify programming different elements of the website; and operating systems provide functionality through "drivers" that interface with specific hardware in a way that saves each software developer being concerned with the details of the particular computer being used. ○ In a digital society our privacy and right to participate is often mediated by digital devices; furthermore, there may be some things that are possible to build that shouldn't be built, and informed discussion is needed, in the same way that discussion can be had around nuclear power, genetic modification or climate change if the public have a general understanding of the science. Ethical considerations mean that we should question algorithms that affect our lives (e.g. voting, privacy, job loss), the ownership of intellectual property, and the impact of digital systems on the environment (both positive and negative). ○ The human aspect of computing is also reflected in how it appears in so many disciplines - computational biology and computational linguistics are just two examples of how ideas central to computing are enabling new approaches in other disciplines.
Computer simulations and virtual systems are used to create virtual versions of processes in the physical world, and also to create imagined scenarios. Simulations can be used to reduce cost (e.g. simulating a structure to fine tune it before building it, or simulating different financial scenarios to choose the most effective strategy) and to reduce risk (e.g. simulating dangerous situations to give aircraft pilots experience, or simulating the spread of a disease to determine how best to prepare for an epidemic). Virtual worlds can be created by generating images and sounds artificially, to make the user feel that they are in a world imagined by the designer (including computer games, virtual reality and augmented reality). Virtual machines provide a simulation of a computer, and this approach is widely used because it protects the physical hardware and the software from each other, which can provide a safer and more flexible environment. Artificial Intelligence models human intelligence, in an attempt to replicate human decision making and reasoning. These virtual representations take advantage of the unique properties of digital devices that enable a system to work on vast amounts of data, and if something goes wrong, they can be re-started in full working order by simply restoring some data, which is considerably simpler than reinstating physical objects that have been damaged or placing humans in a dangerous situation. Digging deeper: ● The virtual representation of a real-world phenomenon is often referred to as a model since it is an approximate, but useful, version of the original scenario; this could be a model of the forces on a physical structure, a model of a financial scenario, or a model of the objects in a 3-dimensional image being viewed on a screen or a virtual headset. ● Simplified models can be used because some details will make (almost) no difference to the solution to a problem; abstracting out those details can save time and space, and avoid having to capture detail for no material purpose. ● Simulation can be used in science where empirical or theoretical approaches won't work. Simulation has become a "third paradigm" of science, joining experiment and theory as an approach to discovering new knowledge. ● Games and virtual worlds create a new environment that may never exist in the physical world (such as a fantasy game or animated movie), or they may seek to model something in the real world as accurately as possible (such as a flight simulator or the spread of disease). ● Computer graphics and visualisation systems enable us to project 3-dimensional models onto a computer display. ● Computer systems also model the world in real time - for example, databases and spreadsheets are used to track the amount of money in a bank account or the score of a student; such models abstract key ideas from the world. ● Artificial intelligence is still a computer program, and so subject to the rules and limitations of computer programs (for example, they may contain errors); however, they may be sufficiently effective that they no longer appear to work as a conventional program. ● Large, detailed models (big data) can be used to search for patterns (data mining/machine learning) that may not be obvious in the physical world. ● Queuing systems are a common basis of simulation, where the system tracks entities (such as data on a network, or customers in a store) by considering their activities to be a series of queues, waiting for various services. ● Although we are modeling the "physical world" with simulations, a computer is still a physical device, and the data and programs are stored physically. However, they are on a completely different scale, and are stored in a way that is very flexible - a flight simulator can run on the same physical devices as a disease simulation or a movie animation. ● A virtual machine is essentially a computer being simulated on a computer - this is a way to be able to give someone access to computing resources with an extra level of flexibility, while isolating them from the original hardware. A simple virtual machine might be an independent environment running on a local desktop computer, or it could be on a large scale as in cloud computing, where a remote user can pay to use some amount of computing resources on a large system.
Modern computing systems provide access to data and resources that if used inappropriately could breach privacy, provide unauthorised access to financial data or other resources, or even bring about physical harm. Security professionals often say that the weakest link in the security of a computer system is the user, and so it is essential that all computer users understand basic computer security principles. These principles include confidentiality (not allowing unauthorised access to information), availability (legitimate users can access their information), and integrity (the information is accurate). Computer users must be aware of and understand the tools and techniques that they can use to make their computing environment more secure. These tools include encryption methods, detecting and blocking attacks, authenticating who is accessing a system, and allowing users to recover from damage, whether malicious or accidental. Digging deeper: ● The need for security is because of human issues. We work within codes of ethics, such as conferring some rights to privacy. Digital representations now control our ownership of property (particularly digital cash) and so traditional crime (such as theft) has now entered the digital world, and requires digital solutions. We also need to allow for human error, such as accidentally deleting or changing information. ● The importance of computer security highlights the value of educating people about it. For example, understanding the basic idea of Public Key Cryptography can help users to feel secure when communicating online, and understanding how passwords are stored can help a user to know why their password should have particularly characteristics. ● Cyber security is now a crucial part of a nation's defence. Nations can be attacked through the internet, and because so many aspects of our lives are controlled by digital systems, an attack on areas such as financial systems, power generation or food supply could have disastrous consequences. ● Another reason for attack is taking over computing resources to do work for the intruder e.g. loading programs on other people's computers to send spam or spread viruses. ● Balanced against this, we need to give appropriate people access at appropriate level as conveniently as possible. ● Security applies to communication systems as well as data storage; physical security (such as building access) is also commonly controlled digitally. ● Security doesn't just involve preventing intrusion; a "denial of service" attack simply overloads a system to prevent legitimate clients from using it, which could put a company out of business or prevent a government from doing its job. ● A key part of good security is having suitable backup, both for data and processing systems, and testing it to ensure that it would work if needed. ● Encryption is a central tool in computer security because it enables data to be changed so that an eavesdropper cannot easily read it. But this raises a new problem: how can people in different locations (such as an online store and a customer) set up a secure connection using secret encryption keys if those keys have to go through the same secure network that the eavesdropper is watching!? Public key cryptography provides a solution to this problem, where, remarkably, it is possible set up a communication and exchange messages in full view of an untrusted third party, without them being able to decode any of the messages. ● There are many cryptographic protocols that enable us to do things that might not seem possible, such as digital signatures that verify the source of a document; making cash payments without knowing who it came from; secure time-stamping where the time of an event or agreement can be recorded in a way that can't be modified; and electronic voting, where each person can verify that their vote was counted correctly, yet not be able to find out how others voted. ● Trying to find holes in security is an important role. A "white hat hacker" is someone who attempts to find security problems, but instead of exploiting the problem, they arrange to have it fixed before a "black hat hacker" can use it for negative purposes.
Digital systems have many components that can run independently; these components can be working in parallel, and on independent schedules. Parallelism occurs at many levels in digital systems, from instruction execution on a CPU, to multi-core systems in a laptop, to data being transmitted over a network through multiple routes, to large "big data" systems that process vast quantities of data in small chunks and combine the results. When a computational task is being spread over several independent parts of the system, considerable care is needed to make the most of the ability to spread the work over multiple devices. Problems need to be broken up into as many parts as possible that can be processed independently and recombined, and the dependency between these operations can restrict how easily a problem can be broken into parts. Digging deeper: ● Computing power is commonly expanded by using multi-processor systems working in parallel; for example, even common desktop computers use multiple "cores" to spread the processing load across several processors. High performance computers can have hundreds or thousands of processors working in parallel, and "cloud" computing can involve arbitrary numbers of devices being applied to a task. A computer system might also involve multiple programs running independently, but communicating with each other ( ● All of these situations require very careful coordination of the independent processes so that information is collated in the correct order when each process finishes. There is also the challenge of breaking a problem into many parts so that each part can be processed efficiently and independently, and then combined to provide a suitable solution to the problem. ● A key challenge is that applying twice as many processors doesn't necessarily solve a problem twice as fast; often there are parts of a solution that are needed before another part can be started on. ● Concurrent processes need to be designed carefully to avoid race conditions (where the order that events happen is critical), deadlocks (where two processes are both waiting for each other) and resource starvation (where some tasks prevent others from getting access to resources, such as a denial-of-service attack). ● Time dependent operations distinguish computing from algebra; for example, the sequence x=2; x=3 is meaningful in a computer program (x ends up with the value 3), but a contradiction in maths (x can't be 2 and 3 at the same time); and y=x+1; x=3 has an algebraic solution that is different to what would happen in a typical program because it depends on the order in which the instructions are executed. ● A related issue is "time slicing", where multiple processes are given turns at a small share of time on a machine, which makes it appear that each of them is running independently. This can happen on a single-user machine (e.g. running the clock at the same time as a word processor program), but also happens on computing systems that deal with multiple users (e.g. a website serving information to multiple clients). Each user may see the system as serving them alone, yet the server is designed to carefully switch between doing tasks for each user to give this appearance.
Very few digital devices are an "island" - most are connected by wired or wireless networks, including local systems such as Bluetooth or USB connections. The goal is to get data through the networks as quickly as possible. However, networks are prone to errors from faulty components or transmission interference, and are also vulnerable to attack from people wanting to eavesdrop on the data or prevent it getting through. Techniques are available to minimise these issues, to the extent that people use wireless data and the Internet for sending important and private information without being concerned about reliability and security. Protocols that ensure that the data has arrived safely and efficiently are essential for almost any situation: personal communications, commercial transactions, or military control all need to be sure that the data gets through reliably. Digging deeper ● Communication protocols typically break data into packets, and use ideas like acknowledgement, time-outs, cryptographic protocols and compression to make sure data has got through correctly, efficiently and securely. ● These protocols are often expressed in "layers", from the details of the physical connectors and electronic specifications, through to details such as breaking data into packets, numbering them, and acknowledging that they have been received, and at the highest level, specifying how a computer program can interface with a program on another computer. ● Protocols are the basis of a large variety of services such as the internet (e.g. the Internet Protocol, IP), the web (e.g. the Hypertext Transfer Protocol, http), secure data transfer (e.g. https) and e-mail (e.g the Internet Message Access Protocol, IMAP). Protocols are needed even to simply download a photo from a camera to a desktop computer (e.g. Bluetooth or USB). ● Protocols are created by humans, and are subject to negotiation; standards are created by considering competing options, and selecting a common approach that enables different devices to work together effectively. Sometimes the selection is done by committees, industry organisations and joint working groups (such as IPv6), and other times de facto standards emerge because of their wide adoption (such as HTML).


As said before, ZombieVille [1997] is a DOS game that was released by Psygnosis in an uncompleted state. It is considered abandon-ware as the game received negative initial reception and forgotten through the years.
The MS-DOS game contains characters as seen in the following slide-show:
(Note that these are just some of the characters in the game.)
Because of the nature of MS-DOS games are developed with 'in-house' methods and formats, file ripping isn't done by conventional means. My luck for trying to rip/view character sprites is basically measured within the following slide show:
I have used TiledGGD and TextureFinder 1.3.2 to help me find the character sprites. However, as seen in previous slide-show,
I have more luck using said T.F. because it can generate the proper color pallet and proper resolution used in the game.
The only file formats that I have been able to work with are .RAW* and .SPR. The .RAW* format tends to be a wild-card where
it can be an image or a sound.
However, I have not been able to rip character sprites as seen from the first slide show above as of yet.
I was only able to rip some static sprites that were used for backgrounds and the health "heads-up-display" screen.
I believe some of the character sprites
might be stored in MATT_NXXX.ANM, or in .DAT files files. I'm not entirely sure since there's no easy way of seeing them nowadays.
It is generally said that if a game cannot have its sprites ripped from the game, then the next step is to screen-shot and
paste all sprites into a single sheet. The reason why I would not proceed with this method is because of the following:
This bounty is set to: $50 USD For submitting usable character sprite sheets.
BONUS: Showing the process of how it was done. +$25 USD
The reason why I have requested this bounty is because for the following reasons:
If you need a copy of the abandon-ware PC game, please click the following button with a computer browser.
Download MS-DOS Copy of Zombieville 1997If you need further details regarding this bounty, please contact me.
Please also let me know if you're outside of USA to figure out the proper payment(s).


I am a curious person who aspires to be a lifelong learner. I love my two dogs and my LEGO collection. Having spent most of my teenage years in Singapore, I still have some Singlish in me, although it might have evolved into a new variation with an Indonesian accent. I've also lived in Seattle, Osaka, and spent a little bit of time in San Fracisco to attend a coding bootcamp.
Investment Manager at Genesia Ventures, a Japanese fund investing early-stage tech companies in Japan and Southeast Asia.
Became interested in Product during my role as a Software Engineer. Currently in the process of deepening my knowledge on Scrum, an agile process framework.
Always optimistic about blockchain, especially Ethereum. Gained familiarity with foundational Ethereum concepts and smart contracts through ConsenSys Academy Developer Bootcamp
Attended Dev Bootcamp, a 19-week intensive, in-person program for full-stack web development in San Francisco, worked as a software engineer at a Financial Technology company for a year, and now coding and practicing on my free time.
Investors meet with hundreds of founders throughout the year, and they range from first-time founders to founders who have launched, failed or exited... more
According to Johns Hopkins Coronavirus Resource Center, 188 countries out of about 200 countries in the world had reported at least one case of COVID-19... more


--- layout: post title: Entities , How many ways do I count thee ? date: 2008-08-17 19:51:30.000000000 -04:00 type: post published: true status: publish categories: [] tags: - Astoria - Components - Demo - Documentation meta: _encloseme: '1' orig_url: http://blogs.msdn.microsoft.com/b/phaniraj/archive/2008/08/18/entities-how-many-ways-do-i-count-thee.aspx orig_site_id: '7524' orig_post_id: '8875636' orig_parent_id: '8875636' orig_thread_id: '600706' _wds_ratings_users: '0' orig_application_key: phaniraj orig_post_author_id: '56365' orig_post_author_username: PhaniRajuYN orig_post_author_created: Nov 10 2006 05:47:39:000PM orig_is_approved: '1' orig_attachment_count: '0' orig_url_title: http://blogs.msdn.com/b/phaniraj/archive/2008/08/17/entities-how-many-ways-do-i-count-thee.aspx opengraph_tags: | author: login: phanirajuyn email<EMAIL_ADDRESS>display_name: Phani Raju MSFT first_name: '' last_name: '' ---
Its a common ask that we introduce aggregating mechanisms in Data services so that one can do a Count of
the number of entities present in an EntitySet easily.
In this blog post , I will outline one method of implementing a “Count” method that works for you.
The interface to the count method will be
http://<ServiceEndPoint>/Count?entitySetName='<entitySetName>'
On the server-side , we will write a Service Operation that takes the name of the EntitySet as an input parameter.
[WebGet] public long Count(string entitySetName) { //Implementation goes here }
In your Service Operations / Interceptors , you have access to the CurrentDataSource which represents your data providers.
The entity sets are properties off of the CurrentDataSource. We will get the entityset off of the CurrentDataSource
and get the count of entities by casting it to IListSource.
[WebGet] public long Count(string entitySetName) {
long countOfEntities = 0; //Get the Property off of the CurrentDataSource PropertyInfo esProperty = this.CurrentDataSource.GetType().GetProperty(entitySetName); //Get the EntitySet off of the CurrentDataSource object esValue = esProperty.GetValue(this.CurrentDataSource, null); //Cast the EntitySet to IListSource IListSource genericESList = esValue as IListSource; //Get the count of entities by fetching the list and getting the value of its "Count" Property countOfEntities = genericESList.GetList().Count; return countOfEntities; }
we will make an extension method on the data service context that takes the name of the entityset and returns the count.
DataServiceContext nwContext = new DataServiceContext( new Uri("ServiceRoot") ); long countOfProducts = nwContext.Count("Products");
Extension method on the DataServiceContext to retrieve count of entities in entityset on the server .
public static long Count(this DataServiceContext context, string entitySetName) { //Call the ServiceOperation on the server side passing the entitySetNameas a parameter var results = context.Execute<long>(new Uri(String.Format("Count?entitySetName='{0}'", entitySetName), UriKind.RelativeOrAbsolute)); //Get the result off of the IEnumerable long count = results.First<long>(); //return the count return count; }
[WebGet] [SingleResult] public long Count(string entitySetName) { long countOfEntities = 0; if (entitySetName == null) { throw new ArgumentNullException("entitySetName"); } //Get the Property off of the CurrentDataSource PropertyInfo esProperty = this.CurrentDataSource.GetType().GetProperty(entitySetName); if (esProperty == null) { throw new ArgumentException(String.Format("No EntitySet named {0} found on the DataSource", entitySetName)); } try { //Get the EntitySet off of the CurrentDataSource object esValue = esProperty.GetValue(this.CurrentDataSource, null); //Cast the entitySet to IListSource IListSource genericESList = esValue as IListSource; //If the cast succeeded if (genericESList != null) { countOfEntities = genericESList.GetList().Count; } } catch (Exception exception) { throw new DataServiceException("'Count' method Failed with , see InnerException -->", exception); } return countOfEntities; }
public static class ClientExtensions { /// <summary> /// This Method returns the count of the number if entities present in an Entityset /// </summary> /// <param name="context">The DataServiceContext which contains the entities</param> /// <param name="entitySetName">The EntitySetName whose entities should be counted</param> /// <returns>The number of entities in the entityset</returns> /// <example> /// long countOfProducts = context.Count("Products"); /// </example> public static long Count(this DataServiceContext context, string entitySetName) { //Call the ServiceOperation on the server side passing the entitySetName as a parameter var results = context.Execute<long>(
new Uri(String.Format("Count?entitySetName='{0}'", entitySetName), UriKind.RelativeOrAbsolute)
); //Get the result off of the IEnumerable long count = results.First<long>(); //return the count return count; } }
In a future post , I will talk about how to off load the counting work to your database , if you have a relational database
as your backend.


Media mogul, Braves owner backs Bloomberg, says Trump causing 'chaos'
by Sam DormanMedia mogul John Malone indicated on Thursday that President Trump wasn't the right person to lead the country, arguing that his administration had produced "chaos."
“Half the people that he’s hired and thrown under the bus are now trying to kill him. I mean, what kind of thing is that? It’s chaos," he told CNBC.
“I just don’t think he’s the right guy to do it. He just doesn’t build a team, I think that’s the No. 1 problem."
Malone is the chairman of Liberty Media, which owns the Atlanta Braves baseball team and has a 71 percent ownership of Sirius XM satellite radio.
BLOOMBERG FILES TO PLACE NAME ON BALLOT IN TEXAS
His comments came as House Democrats pressed on with an impeachment inquiry against the president and Trump's administration saw a succession of high-profile departures like former National Security Adviser (NSA) John Bolton. Bolton was Trump's third NSA since he took office in 2017.
Malone said that he would support former New York City Mayor Michael Bloomberg if he ran for president in 2020, although he wasn't sure if the billionaire had "much of a chance."
CLICK HERE TO GET THE FOX NEWS APP
While Bloomberg hasn't officially announced his run, he's filed to place his name on multiple state primary ballots, including Texas and Michigan.
During his Thursday interview, Malone added that Trump has done a lot of "great" things but "I just don’t think he’s the right guy to do it."


{% extends 'channel/templates/settings_base.html' %} {% block settings %}
Edit the channel description and URL or upload an icon
Select a custom color or upload an image as your background.
Add blogs, photos, and other RSS or Atom feeds to the channel
Create a channel badge for placing on another Web site.
Tags Modify


{% extends "global/Page.html" %} {% load otree static %} {% block title %} Bid {% endblock %} {% block styles %} {% endblock %} {% block content %}
The value of the object to you is {{ player.private_value }}. If you win the auction, you would have a payoff of {{ endowment_plus_private_value }} - second highest bid.


Class SchemaSearchRequest
Request to search schemas
Inheritance
Inherited Members
Namespace: System.Dynamic.ExpandoObject
Syntax
public class SchemaSearchRequest
Properties
AggregationFilters
Special filters used to filter down independently the aggregations' values and the search results on specific conditions.
For the search results, the aggregation filters are used to create a Filter that is put in AND with the eventual existing Filter of the search request to nail down the search results. The filters generated
by the aggregation filters are put in OR each other if they have the same AggregationName, and then such groups are put in AND.
For the aggregation values, only the original Filter of the search request is used to nail down the data to be considered for the aggregations. Then, on top of that, for each aggregator in the search request, a Filter is created to filter down the
aggregation results of that aggregation: depending if the AggregationName of the AggregationFilter matches the AggregationName of the Aggregator, the filter is put in OR (if it matches) or in AND (if it does not match it).
Moreover, an AggregationFilter ensures that the related value is returned in the AggregationResults also if the top aggregation values returned by default do not contain it.
Declaration
public ICollection<AggregationFilter> AggregationFilters { get; set; }
Property Value
|
System.Collections.Generic.ICollection<AggregationFilter>
|
Aggregators
List of aggregators that defines how the items should be aggregated.
Declaration
public ICollection<AggregatorBase> Aggregators { get; set; }
Property Value
|
System.Collections.Generic.ICollection<AggregatorBase>
|
DebugMode
Enable debug mode: additional debug information regarding the query execution and reason of the matched documents are returned in the SchemaSearchResult.
Warning! It severely affects performance.
Declaration
public bool DebugMode { get; set; }
Property Value
|
System.Boolean
|
Filter
An optional filter to limit the schemas.
Declaration
public FilterBase Filter { get; set; }
Property Value
|
FilterBase
|
Limit
Limits the number of the returned schemas. Defaults to 30.
Declaration
public int Limit { get; set; }
Property Value
|
System.Int32
|
PageToken
The token used to retrieve the next page of results. It must be null on first request and only filled with the returned pageToken to request next page of results.
Declaration
public string PageToken { get; set; }
Property Value
|
System.String
|
RightsFilter
Limits the schemas to the ones the user has the specified MetadataRights.
Declaration
public ICollection<MetadataRight> RightsFilter { get; set; }
Property Value
|
System.Collections.Generic.ICollection<MetadataRight>
|
SearchBehaviors
An optional list of search behaviors. All the passed behaviors will be applied in the specified order.
Declaration
public ICollection<SearchBehavior> SearchBehaviors { get; set; }
Property Value
|
System.Collections.Generic.ICollection<SearchBehavior>
|
SearchLanguages
When searching in multi language fields, limit the searchable fields to the ones corresponding to the specified languages.
If not specified, all metadata languages in the system are used.
Declaration
public ICollection<string> SearchLanguages { get; set; }
Property Value
|
System.Collections.Generic.ICollection<System.String>
|
SearchString
The string used to query the data. The Lucene query string syntax is supported.
Declaration
public string SearchString { get; set; }
Property Value
|
System.String
|
Sort
Sorts the search results. Currently only sorting on the Names property is allowed.
Declaration
public ICollection<SortInfo> Sort { get; set; }
Property Value
|
System.Collections.Generic.ICollection<SortInfo>
|
Methods
FromJson(String)
Declaration
public static SchemaSearchRequest FromJson(string data)
Parameters
|
System.String
data
|
Returns
|
SchemaSearchRequest
|
ToJson()
Declaration
public string ToJson()
Returns
|
System.String
|


Input a STEAMID to find out the metacritic average of the game library.
Please enter the ID for the feed you wish to fetch.
76561198045250473
76561198019392997
76561198025500278


|
Hi [HOSTCOMPANY_REP.PRI_FIRSTNAME]
[INTERN.PRI_FIRSTNAME] has advised me that your company ([HOSTCOMPANY.PRI_CPY_NAME]) has agreed to provide him/her with a 12 week internship titled [INTERNSHIP.PRI_NAME].
Before [INTERN.PRI_FIRSTNAME] is allowed to start their internship with you, we are required to conduct a visit of your premises to ensure that the physical workplace where [INTERN.PRI_FIRSTNAME] will be working suitable and safe.
I will be calling you in the next couple of days to arrange this visit.
I look forward to speaking to you soon.
Kind Regards
InternMatch
|
|
|


To achieve this, our livelihood programmes focuses on generating sustainable livelihoods. This is done through capacity building, fostering community links and promoting small businesses. B-Link India puts special focus on entrepreneurial ventures, which are owned by women. B-Link through its livelihood programmes promotes microfinance, Self Help Groups, capacity building and small businesses. It also fosters linkages between community collectives and financial institutions. B-Link also focuses on improving the literacy, numeracy and critical thinking skills to promote sustainable livelihoods.


FACE/OFF Review by Luke Buckmaster<EMAIL_ADDRESS>Been there, done that, seen this, seen that. This seems to be the attitude that many filmgoers share regarding one of the most well known yet over done movie genres ever - action. Can you blame them? Well after hundreds of tiring Van Damne/Bruce Willis style movies, I hardly think so. But what is this - a light at the end of a long, dark tunnel? Maybe, just maybe, I've found the first proper action film equal to The Rock.
If you think you know what on screen action is, wait until you see it John Woo style. Beginning as a popular Chinese film director, Woo's talents were recognized as something truly special, and it was just a matter of time until he entered the Hollywood scene. And when he did, he not only left a mark of excellence but also set incredibly high standards for the industry after his successful creations Hard Target, Broken Arrow and now Face/Off. What's so special, you ask, about his work? Well Woo surely goes where no director has ever been before, and finds himself working the movie into unpredictable, incredibly suspenseful scenes of man to man conflict and a host of other small surprises. However the greatest part of his films is not these mesmerizing scenes, but the fact that he never loses site of the big picture - which keeps the films running slick and smooth all the way through.
Woo's latest film, Face/Off, restores faith in the action genre and gives audiences something to chant and rave for, with the performances of John Travolta and Nicholas Cage worth the price of admission alone. Just as the suspense thriller Scream made up for decades of pathetic horror films, Face/Off does exactly the same thing with action films, making it a worthy addition to anyone's ticket collection. Never before has an action duo looked so good on the silver screen. Never before has the good guy worn the bad guys face. Never before have I apologized to the person sitting next to me for cheering for the wrong guy.
His names Castor Troy (Cage), and he's the slickest, most cool bad dude since Bobba Fett of Star Wars. Surrounded by weapons, henchmen, drugs and good looking women, Troy's career is exactly the way he wants it - a whole lot of fun. On the other side of the spectrum is Sean Archer (Travolta) an FBI agent who has perused Troy for six years after he accidentally assassinated his infant son while aiming for Sean. Archer, basing his whole life around trapping Troy, is all too glad to hear that his mentor is in town and rushes out to catch him in the early minutes into the film. But after finally beating Troy at his own game and sending him into a coma, more bad news is ahead. Archer soon discovers that Troy rigged up a bomb that will blow Los Angeles's to pieces, and only one person knows the location of it - Troys half witted brother (who bears a striking resemblance to Radar off Mash). After Archer fails to make Troys gang spill the beans, he is left with only one option - to enter the prison looking like Troy so he can find the location from his brother. A plastic surgeon removes the faces of both Archer and Troy so that the FBI agent assumes the identity of his nemesis so he can prevent a disastrous detonation.
As far as a twist in the plot is concerned, the one coming up is a beauty. When Archer is busy getting used to being inside the master criminals body, Troy wakes up from his comer on the wrong side of the bed - not at all happy with the fact that he is without a face. However after making a few firm phone calls, his henchmen come running to the scene and force the surgeon to put the only face on Troy that is available - Archer's. Assuming his identity, Troy couldn't be happier with the situation after burning all evidence that a face transplant ever existed and eagerly getting to know Archer's wife Eve (Joan Allen).
Trapped inside each other's bodies, the two arch enemies discover things about each other that they never knew could exist such as family commitments and a clash of different identities inside different identities. But in no time the showdowns become blood baths of action and gripping suspense courtesy of Woo's guiding hand, which can be described as nothing less than brilliant. The action scenes are quite obviously the height of the film, giving fans of both actors a great time as they witness them playing both the good guy and the bad guy for the first time.
Although I admit that the whole idea of such a farcical transplant is laughable, not for one second can you look back on the film and criticize it for attempting something original and entertaining. A silly idea, yes, but the entire movie is crafted so well that it is easily forgotten in a mess of action that is unmistakably the best we've seen so far this year.
Face/Off is quite honestly an outstanding look at what can be achieved with even the most ridiculed and overused Hollywood genre, and delivers non stop slabs of action that will glue you to your seat in anticipation. This film truly is top class, and never before has action looked this good.
5 STARS Woo takes action to new heights
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


--- layout: cypress title: Components/Panel --- {% capture content %}
Repositories
All Public Private Sources Forks