on 09-Sep-2018 (Sun)

you MUST have a user

Insects are the only invertebrates to have developed active flight capability

pplication Programming Interface

The term API is an acronym, and it stands for “Application Programming Interface.”

Think of an API like a menu in a restaurant. The menu provides a list of dishes you can order, along with a description of each dish. When you specify what menu items you want, the restaurant’s kitchen does the work and provides you with some finished dishes. You don’t know exactly how the restaurant prepares that food, and you don’t really need to.

Similarly, an API lists a bunch of operations that developers can use, along with a description of what they do. The developer doesn’t necessarily need to know how, for example, an operating system builds and presents a “Save As” dialog box. They just need to know that it’s available for use in their app.

This isn’t a perfect metaphor, as developers may have to provide their own data to the API to get the results, so perhaps it’s more like a fancy restaurant where you can provide some of your own ingredients the kitchen will work with.

But it’s broadly accurate. APIs allow developers to save time by taking advantage of a platform’s implementation to do the nitty-gritty work. This helps reduce the amount of code developers need to create, and also helps create more consistency across apps for the same platform. APIs can control access to hardware and software resources.

APIs Make Life Easier for Developers

Let’s say you want to develop an app for an iPhone. Apple’s iOS operating system provides a large number of APIs—as every other operating system does—to make this easier on you.

If you want to embed a web browser to show one or more web pages, for example, you don’t have to program your own web browser from scratch just for your application. You use the WKWebView API to embed a WebKit (Safari) browser object in your application.

If you want to capture photos or video from the iPhone’s camera, you don’t have to write your own camera interface. You use the camera API to embed the iPhone’s built-in camera in your app. If APIs didn’t exist to make this easy, app developers would have to create their own camera software and interpret the camera hardware’s inputs. But Apple’s operating system developers have done all this hard work so the developers can just use the camera API to embed a camera, and then get on with building their app. And, when Apple improves the camera API, all the apps that rely on it will take advantage of that improvement automatically.

This applies to every platform. For example, do you want to create a dialog box on Windows? There’s an API for that. Want to support fingerprint authentication on Android? There’s an API for that, too, so you don’t have to test every different Android manufacturer’s fingerprint sensor. Developers don’t have to reinvent the wheel over and

Once I'm comfortable with the main lines, I create a PGN file with them (and eventually some key variations). There are far too many lines in an opening book to memorize them all, so when I go through a third time, this time looking at all the variations as well, I evaluate the variations as worth knowing or otherwise. Those deemed worthwhile get added to the file, while those that I would never intend / allow to be played are immediately forgotten

When all is said and done, excluding traps, I like my PGN file to have no more than 10-20 variations. Annotations are also generally good, as you might forget some of the ideas, and it would be bad to memorize a line and forget whether it is good or a trap to avoid. I also go back through the games in the book and include the relevant ones in my PGN for reference.

There are six steps in the original technique:

1. Decide on the task to be done.
2. Set the pomodoro timer (traditionally to 25 minutes).^[1]
3. Work on the task.
4. End work when the timer rings and put a checkmark on a piece of paper.^[5]
5. If you have fewer than four checkmarks, take a short break (3–5 minutes), then go to step 2.
6. After four pomodoros, take a longer break (15–30 minutes), reset your checkmark count to zero, then go to step 1.

code that appears in a .pdf document (e.g., presentation slides and as- signments) may contain hidden or unusual symbols

Never include Comment Boxes or images in your submissions. Do not copy-and-paste from the Interactions window or from .pdf documents into the Definitions window, or your assignment may become unmarkable.

Always follow a semicolon by a space to improve readability.

Additional comments should begin with capitals but do not need to end with periods.

Use in-line comments sparingly.

file should start with a header to identify yourself, the term, the assignment and the problem.

Insert two consecutive blank lines between functions or “function blocks”, which include the documentation (e.g., design recipe) for the function.

Insert one blank line before and after the function definition: do not use more than one consecu- tive blank line within a function block.

If you have many functions and/or large function blocks, you may want to insert a row of symbols (such as the * ’s used in the file header above) to separate your functions.

If the question asks you to write more than one function, the file should contain them in the order specified by the assignment.

Helper functions are placed above the assignment function they are helping.

Indentation plays a big part in readability. It is used to indicate level of nest- ing, to align related subexpressions (e.g., arguments of a function), and to make keywords more visible. DrRacket’s built-in editor will help with these.

If you start an expression (my-fn and then hit enter or return, the next line will automat- ically be indented a few spaces.

However, DrRacket will never break up a line for you, and you can override its indentation simply by putting in more spaces or erasing them.

DrRacket also provides a menu item for reindenting a selected block of code (Racket > Reindent) and even a keyboard shortcut reindenting an entire file (Ctrl+I in Windows).

When to start a new line (hit enter or return) is a matter of judgment. Try not to let your lines get longer than about 70 characters, and definitely no longer than 80 characters.

Style marks may be deducted if you exceed 80 characters on any line of your assignment.

In DrRacket there is a setting you can change to show you when you’ve exceeded the line length: Edit -> Preferences -> Editing tab -> General Editing sub-tab -> Maximum character width guide.

your examples and tests may exceed the line length guidelines when there is no obvious place to break the line.

If indentation is used properly to indicate level of nesting, then closing parentheses can just be added on the same line as appropriate.

Some styles for other programming languages expect that you place closing brackets on sep- arate lines that are vertically lined up with the opening brackets. However, in Racket this tends to negatively effect the readability of the code and is considered “poor style”.

For conditional expressions, placing the keyword cond on a line by itself, and aligning not only the questions but the answers as well can improve readability (provided that they are short). However, this recommendation is not strictly re- quired. Each question must appear on a separate line, and long questions/answers should be placed on separate lines.

choose names for functions and parameters that are descriptive, not so short as to be cryptic, but not so long as to be awkward. The detail required in a name will depend on context: if a function consumes a single number, call- ing that number n is probably fine.

It is a Racket convention to use lower-case letters and hyphens, as in the identifier top-bracket-amount. The rare exception is when proper names are used such as Newton. In other languages, instead of top-bracket-amount one might write this as TopBracketAmount or top _ bracket _ amount, but avoid these styles when writing Racket code.

predicates that re- turn a Boolean value usually end in a question mark (e.g. zero?)

functions that do conversion use a hyphen and greater-than sign to make a right arrow (e.g. string->number). This convention is also used in contracts. In some course materials you may see an actual arrow produced (e.g. string→number), but you should always type them as two characters (->).

If the value of cost-per-minute changes, it is much easier to make one change to the definition of the constant than to search through an entire program for the value 0.75. When this value is found, it is not obvious if it refers to the cost per minute, or whether it serves a different purpose and should not be changed.

As values used in testing and ex- amples become more complicated (e.g., lists, structures, lists of structures), it can be very helpful to define named constants to be used in multiple tests and examples.

• Use one blank line before and after your function definition.

Make it clear where function blocks begin and end (i.e., two blank lines between function blocks).

Style marks may be deducted if you have poor headers, identifier names, whitespace, indentation or layout.

If you hand in only code, even if it works perfectly, you will earn only a fraction of the marks available.

The purpose statement has two parts: an illustration of how the function is applied, and a brief description of what the function does. The description does not have to explain how the computation is done; the code itself addresses that question.

The purpose starts with an example of how the function is applied, which uses the same parameter names used in the function header.

Do not write the word “purpose”.

The description must include the names of the parameters in the purpose to make it clear what they mean and how they relate to what the function does (choosing meaningful parameter names helps also). Do not include parameter types and requirements in your purpose statement — the contract already contains that information.

If the description requires more than one line, “indent” the next line of the purpose 2 or 3 spaces.

If your purpose requires more than two or three lines, you should probably consider re-writing it to make it more condensed. It could also be that you are describing how your function works, not what it does.

If you find the purpose of one of your helper functions is too long or too complicated, you might want to reconsider your approach by using a differ- ent helper function or perhaps using more than one helper function.

The contract contains the name of the function, the types of the arguments it con- sumes, and the type of the value it produces.

If there are important constraints on the parameters that are not fully described in the contract, add an additional requires section after the contract. For example, this can be used to indicate a Num must be in a specific range, a Str must be of a specific length, or that a (listof ...) cannot be empty. Indent multiple requirements.

The examples should be chosen to illustrate ‘typical’ uses of the function and to illuminate some of the difficulties to be faced in writing it.

Examples should cover each case described in the data definition for the type consumed by the function.

The examples do not have to cover all the cases that the code addresses; that is the job of the tests, which are designed after the code is written.

It is very useful to write your examples before you start writing your code. These examples will help you to organize your thoughts about what exactly you expect your function to do. You might be surprised by how much of a difference this makes.

Typically, for recursive data, your examples should include each base case and at least one recursive case.

Develop your purpose, contract and examples before you write the code for the function.

use the provided basic tests when you submit your assignments. If your code does not pass these tests, then you should carefully check your submission for spelling errors and the like.

You do not have to repeat your examples in your tests section. Your examples also count as tests.

Make sure that your tests are actually testing every part of the code. For example, if a conditional expression has three possible outcomes, you have tests that check each of the possible outcomes.

your tests should be directed: each one should aim at a particular case, or section of code.

Some people write tests that use a large amount of data; this is not necessarily the best idea, because if they fail, it is difficult to figure out why.

Others write lots of tests, but have several tests in a row that do essentially the same thing. It’s not a question of quantity, but of quality.

design a small, comprehensive test suite.

Never figure out the answers to your tests by running your own code. Work out the correct answers independently (e.g., by hand).

Do not use the word “helper” in your function name: use a descriptive function name.

Helper functions only require a purpose, a contract and at least one illus- trative example. You are not required to provide tests for your helper functions (but often it is a very good idea).

we have seen students avoid writ- ing helper functions because they did not want to provide documention for them. This is a bad habit that we strongly discourage.

Writing good helper functions is an essential skill in software development and simply writing a purpose and contract should not discourage you from writing a helper function.

Marks may be deducted if you are not using helper functions when appropriate. Helper functions should be placed before the required function in your submission

Functions we ask you to write require a full design recipe. Helper functions only require a purpose, a contract and an example.

If we ask you to write two mutually recursive functions, only one of the functions requires tests.

When using wrapper (primary) functions, only one of the functions requires tests. If the required function is the wrapper function, then include the examples and tests with it. Otherwise, use your judgement to choose the function where ex- amples and tests seem most appropriate.

For functions defined with a local block, no tests or examples are necessary

Add a blank line after each local function definition.

Add a blank line after each block of local constant definitions, as you would for non-local constant definitions.

A user-defined type can be a structure (defined with define-struct) or simply a descriptive definition.

With the exception of the Racket built-in types (e.g., Posn), every user- defined type used in your assignment must be defined at the top of your file (unless an assignment instructs you otherwise).

User-Defined types that appear in contracts and other type definitions should be capitalized (use My-Type, not my-type).

When you define a structure, it should be followed by a type definition, which specifies the type for each of the fields.

A descriptive definition can be used to define a new user-defined type to improve the readability of contracts and other type definitions

For any non-trivial user-defined type, there is a corresponding template for a func- tion that consumes the new type.

Since a template is a general framework for a function that consumes the new type, we also always write a contract as part of the template. For each new data definition, writing a template is recommended, but not required unless otherwise specified.

As you combine user-defined types, their templates can also be combined. See the course handouts for more examples.

general guidelines at the beginning of this guide regarding whitespace, line lengths, having meaningful parameter names, etc. also apply to C.

Every function you write should have a purpose statement. The format in C is nearly identical to the Racket format.

Unlike in Racket, in C you do not have to indicate the contract types.

NOTE: the effects and time components of the contract are only required once they have been introduced in the lectures.

NOTE: whenever feasible, assert any conditions that appear in the requires section.

In CS136, you may adopt any style but you should adhere to consistent usage of indentation, whitespaces, and code layout with the goal of making your code more readable.

• No more than one C statement per line.

• Add a space after commas in function calls and semicolons in for loops.

• Add spaces around operators in expressions to make them easier to read.

• Break long lines of code (more than 80 columns) onto 2 or more lines.

Your code should be presented so that a matching pair of braces is easy to identify and all lines of code within a set of braces should be indented consistently.

• Indentation should be consistantly 2 or 3 spaces (not tab characters).

NOTE that in C (unlike Racket) it is not proper style to place all ending braces on one line (}}}).

In C, the underscore character is often used to separate words within an identifier. No separating character, or a change in case are also common conventions.

An identifier in Racket named one-word? might look like one _ word, is _ one _ word, isoneword or isOneWord in C. The choice is yours on which convention you would like to use but try to be consistent

Edgar Allan Poe is known for his dark, macabre writing. We're not sure if this is a case of life imitating art or vice versa, but Poe's personal life was similarly tragic. The famed poet died at the young age of 40 on October 7, 1849, and how it happened sounds like a page from one of his tales: it remains a mystery.

It will only be a masterpiece ifyou let it! It will of course be entertaining, but what Jacob really wants is to make you (yes YOU!) a better chess player. To do that he needs you to give the puzzles (the heart ofthe book) everything you've got... And then some

Have you ever wondered why most players reach a certain level and stay there forever? They will make (rapid?!) progress as a junior but somewhere in their early twenties the learning curve just flatlines and they will keep the same rating until old age and the law of gravity forces a decline. A lot of these players play a lot of chess, and try to also study and train. So why do they stay at the same level? Well, chess is different from many other activities where you will, almost automatically, keep on getting better throughout your life

the brain needs a special map for these kinds of activities, so it has to be learned at an early age —

That explains why so many players get stuck at a certain level - their map is done!

But that's where Aagaard (and other heavyweights like Dvoretsky and Yusupov) come to the rescue! The books in this series are designed to change the 'chess map' in your brain! Jacob wants to transform that narrow path of finding good moves into a freeway where good moves flow!

So this is the promise: Ifyou read this book and give the puzzles all you've got, it will change the chess map in your brain and make you a better player.

Your brain doesn't want a new freeway, and it doesn't like change and it definitely doesn't like construction work right in the brain's chess-centre when the 'city' is already fully constructed. So it will fight against the improvements and it will fight hard!

Example one: You are solving a puzzle and think you have the solution but there is something 'fuzzy' in one of the lines — so instead of insisting on being sure (forcing your brain to calculate deeper), you check the solution (doh!).

Example two: You are looking at a puzzle and can't decide between two moves, so you decide to check the first move in the solution (to see ifyou are on the right track).

Example three: You have successfully solved, let's say, five puzzles a day for three days, and then suddenly you run out of energy (feel drained) and don't touch the book for a week. When you finally pick it up again you just can't concentrate.

one _ word, is _ one _ word, isoneword or isOneWord

These are all standard brain-tactics to avoid changes. There are many more (your brain is pretty good at this) so you need a strategy to get the job done!

1) Solve the puzzles with a friend. Just meet up and set up the positions and try to solve them (individually of course) - it makes it easier to concentrate when you are competing with a friend.

2) Set a goal and give yourself a reward for achieving it. I do this all the time -an example could be that I allow myself to buy something (Thank you for the iPad, Jacob!) after doing the first 50 puzzles.

3) Insist on doing at least one puzzle a day for at least a month — make it a top priority (say to yourself that you are not allowed to eat anything on any given day before at least one puzzle is solved).

Attacking chess is conceptually quite simple: the idea is that an advantage in a small area of the board can be more important than a breakdown on the rest of the board, if that small part of the board is where the king is located.

The superiority is fleeting in nature and swift in execution.

It is not that material does not matter, it is needed in order to deliver mate, but it comes second to the other great force of life, and chess, time.

Include all the Pieces in the Attack As a chess trainer this is the obvious place to start teaching how to attack, because this is the place where most of the readers will fail in their own games.

this is where most amateur chess players go astray.

Including all the pieces in the attack is about overpowering your opponent in his keep, about having enough foot soldiers to give up in order for the one lonely killer to make it to the opponent's king

Many attacks fail because the last piece is missing in the attack. The piece that could have been there to clear the way, or even slip in the knife.

Obviously it is not always possible to bring all your pieces into the attack, but to be a good attacking player you need to develop a good feeling of when you can and when you cannot. In order to do this you need a good feeling for:

Momentum: I would say that they are the soul of strategic chess, because the game is taking place around the structures the pawns establish, and creating the positions that benefit your pieces is what chess strategy is all about.

Dynamic chess on the other hand is all about momentum.

If an attack is hanging on a knife edge and success by no means seems certain, it is not the pawn structure or the body count that matters the most, it is the speed with which the attack is carried out.

But there are a few things we can do: we can avoid wasting time; we can threaten something that forces our opponent to make moves that do nothing for his defence — and so on...

A good feeling formomentum -anunderstanding ofhow to bend the laws ofthe physics inorder to progress the attack - is needed if you want to become a good attacker.

Many strong players have never fully developed this and in my opinion not understood that it exists, instead thinking that their attacks failed due to miscalculation.

Colour is a simple idea: that only the Rook and the King are truly colour blind

The Queen has some leanings, while the Knight, Bishop and Pawn can only control one colour of squares at one time.

For this reason it is standard that weaknesses will form on one colour of squares. This happens because we place our pawns to support our pieces. But this also means that the pieces at times will not support the pawns; it is a matter of rank.

their attacking potential, I would rate them like this: queen, knight, bishop, pawn, rook and king; though I am a bit uncertain that the rook and pawn should be ordered that way around.

Attacks are very difficult to carry out without queens or knights, but happen without pawns, rooks and kings all the time.

For this reason it is natural that attacks will happen quite frequently in harmony on one colour ofsquares. A good feeling for this is a strong asset for the attacking player.

Quantity beats Quality A logical follow-on from the basic ideas that pieces can only attack a square once, that time is more important than material and that rooks are not very agile attackers, is that the exchange sacrifice is a big part of attacking chess.

But there are other sacrifices that can propel the attack from promising to decisive; all based on the same underlying principle as include all the pieces in the attack: a piece that does not participate in the attack has no value for the attack

For this reason the quantity of attackers is often more important than the firepower of the attackers themselves. A mate delivered with a pawn is just as valid as a mate delivered with a queen;

Attack the Weakest Square With this theme we are into basic chess theory; which is also relevant for attacki n g chess, of course. An attack of any sort, being the type we discuss in this book, or the slow creeping up of a bigger army, which is what can happen if our attack fails, will be directed at the weaknesses in the position

A chain always breaks at its weakest link, as does a window pane. Only in rare cases where the force is so massive that it can go through anything, is this not the case. Understanding where all of the opponent's weaknesses are and being quick to spot them is an important part ofbeing a good chess player.

Attack the Strongest Square This is more a technique than a theme; based on diversion. You attack one square that the opponent seemingly is in full control of, but because he has to defend it all the same, he will have to make concessions elsewhere in his position.

Evolution/Revolution: The principle is quite simple: attacks happen in waves. First we build up our forces, looking for the right moment to go from mobilization to attack. The mobilization is the evolution; the execution that changes the position for good is the revolution.

What I am trying to teach with this theme is that the wave goes down as well as up. After the position changes, the conditions for our forces will have changed again, and it is often time to build up (evolution) a bit more before making further revolutions. It is an understanding ofhow a short regrouping can be vital for any attack being successful; even ifwe have invested a pawn, piece, rook, queen, or army in the attack. 'Don't panic!' is the short version, because this is all about psychology.

Kill zone: We are the aggressors, the colonialists, the oppressors. We need to create the death ground for the opponent's king — and then we have to make sure he does not escape from it!

Only Move At the heart of defensive chess is the concept of the only move; that there are positions where only one move does not lose and we are able to find this. It can of course also be the only move that fends off the attack, while others allow the opponent to escape unharmed from an overreaching attack.