Game 1: RiceRocks
My original goal with this game was to create a minimalist HTML5 arcade-style game to learn the basics. I translated a game I originally encountered many years in Rice University's Interactive Python Mooc called RiceRocks. This meant the sprites and sounds were all readily available on my PC.
Though translating the game from the original Python to JavaScript wasn't very difficult, it got me thinking on various philosophical issues, and I kept refactoring until it strayed far from the original.
Modularisation
The original Python version of RiceRocks was used to teach OOP, a style I've become disenchanted with. A lot of OOP's key selling points boil down to modular programming.
JavaScript only recently started supporting this, and a few things tripped me up.
Firstly, to get modules to work, the html needs to be modified:

What I found confusing is the module files don't need to be declared here, but the main.js file that imports
stuff from modules needs the type="module"
attribute added.
The gotcha with export is it needs to be declard at the bottom of the module in a curly bracketed, comma separated list. There's no arity declaration, and parameters are not included. The export declaration creates a wish list which would initially be made of stubs, a key part of systematic software design.
A gotcha with
import,
which goes at the top of the client file is the module file needs a path, ie "./module.js"
if it is a sibling
of the main file.
Once I'd figured out the quirks of JavaScript's modules, I could proceed to enjoy the separation of concerns, information hiding, and many other benefits of modules.
Another form of JavaScript modularisation — which uses different conventions — are Web Workers, where the bulk of my code ended up and I'll elaborate on shortly.
Audio
In my first draft of this project when I struggling to understand the myriad Web APIs, I kept one hierarchical diagram with links to documentation on the many objects and their methods, properties and events I was using. The audio part looked like this.
├── BaseAudioContext
│ ├── Constructor
│ │ └── AudioContext()
│ └── Properties
│ └── destination
└── AudioBufferSourceNode
. ├── Constructor/Instantiator
. │ └── BaseAudioContext.createBufferSource()
. ├── Properties
. │ ├── buffer
. │ └── loop
. └── Methods
. . ├── connect()
. . ├── start()
. . └── stop()
I'm more of a graphics than sound guy, and I found all the objects required for audio extremely confusing. It's a bit analogous to graphics in that files containing binary blobs in various formats need to downloaded by the browser and stored in memory to be referenced by named constants.
A context is needed which is conventionally made a global constant whose methods are used to make noise when desired.
Thanks to modularisation, I could move all this complexity into a separate file to be access in my main file by
import { sounds, playSound } from "./sound.js";
where sounds is a key-value store of the four sounds used in the game which can be passed to one function as in
playSound(sounds["missile"]);
Moving from Python to JavaScript, I found it quite eye opening that object-style sounds.missile
is
simply syntactic sugar for associative array-style sounds["missile"]
, revealing that much of OOP is simply
compound data layered in jargon.
For some reason, JavaScript linters complain about using sounds["missile"]
instead of sounds.missile
,
but I think it better style since I can use sounds[Variable]
but not sounds.Variable
, and I prefer
to keep my keys double quoted because it sticks to the JSON convention, and also makes it easier to differentiate between
the key name and variable assigned to it name the same.
The OOP way of writing the playSound standalone function would be to create a class with a name like Sound and then
write something like Sound.prototype.playSound = function() {...}
to be invoked as
sounds.missile.playSound()
, which I find a lot less elegant or reusable.
Graphics
One of the advantages of modularity I discovered here is it that it improves testability, which I find fairly tricky in a game like this.
Though I couldn't abstract image.js down to just two public names, I similary managed to hide much of this complexity in a module accessed with a dictionary of key-value pairs and some functions.
├── Canvas
│ ├── HTMLCanvasElement
│ │ └── Properties
│ │ . ├── width
│ │ . └── height
│ └── CanvasRenderingContext2D
│ . ├── Constructor/Instantiator
│ . │ └── HTMLCanvasElement.getContext()
│ . ├── Properties
│ . │ ├── fillStyle
│ . │ └── font
│ . └── Methods
│ . . ├── clearRect()
│ . . ├── drawImage()
│ . . ├── fillText()
│ . . ├── restore()
│ . . ├── rotate()
│ . . ├── save()
│ . . └── translate()
└── HTMLImageElement
. ├── Constructor
. │ └── Image()
. └── Properties
. . ├── width
. . ├── height
. . └── src
Event-driven programming
Neither OOP nor FP comfortably support what Erlang's late founder Joe Armstrong termed concurreny-oriented programming, specifically event-driven programming, which is related to reactive programming.
This nomenclature is a bit confusing, and has its origin in early operating-systems research. It refers to how communication is done between multiple concurrent processes. In a thread-based system, communication is done through a synchronized resource such as shared memory. In an event-based system, processes generally communicate through a queue where they post items that describe what they have done or what they want done, which is maintained by our single thread of execution. Since these items generally describe desired or past actions, they are referred to as 'events'
—
An Event-Driven Web Framework, Leo Zovic
Event-driven programming can broadly be split into three steps:
- Listeners: In JavaScript, these are created with target.addEventListener(type, listener [, options]); where target is Window, Document, or other HTML element, and type is something like "keyup", "keydown", or "click".
- Handlers: This is addEventListener's second argument, a callback called listener in the documentation.
- A listening loop — the body of a concurrent system.
Step 1: Attaching listeners to targets
My adaption from the Python original, which assumed the game was going to be played on a PC with a keyboard, involved adding touch input for mobile phones. After initially experimenting with the Touch Events API, using touchstart and touchend attached the canvas, I switched to including buttons in my HTML and then using Pointer Events which make a mouse and a finger touch on a mobile phone identical. The buttons also provide a visual clue to website visitors with keyboards which keys will work.
I'll maybe use what I learned about touch events for mobile specific designs in future.
The user interface was created by attaching event listeners to the DOM as follows:
document.addEventListener("keydown", uiListener);
document.addEventListener("keyup", uiListener);
document.querySelector("#upButton").addEventListener("pointerdown", uiListener);
document.querySelector("#upButton").addEventListener("pointerup", uiListener);
document.querySelector("#leftButton").addEventListener("pointerdown", uiListener);
document.querySelector("#leftButton").addEventListener("pointerup", uiListener);
document.querySelector("#rightButton").addEventListener("pointerdown", uiListener);
document.querySelector("#rightButton").addEventListener("pointerup", uiListener);
document.querySelector("#spaceBar").addEventListener("pointerdown", uiListener);
document.querySelector("#spaceBar").addEventListener("pointerup", uiListener);
Like many other programming languages, JavaScript lets you just use the function name with no arguments when invoking it as a first-class citizen, ie a paramater in another function, if the only argument is one generated, which magically reappears where the function is defined.
The reason I converted it to pass inputStates
as an argument even though it's a global constant is it's a
discipline enforced by testing framework Jasmine.
Besides user input events, there are other types of events which weren't immediately obvious to me. These include the many Window events which tell us when to initialise the program because a browser has opened the page, stop things like sound loops when the user closes the tab, and also react to events like the browser window getting resized or the orientation of a mobile phone getting changed.
A snag I initiallyl hit was JavaScript's dreaded "white screen of death" caused by the background image not loading by the time the page was rendered. My initial attempt to fix this worsened the problem by introducing more JavaScript horrors, a "pyramid of doom" along with an async-await blockage.
window.addEventListener("DOMContentLoaded", async function(event1) {
await backgroundImage.addEventListener("load", function (event2) {
...
});
});
I taught myself JavaScript testing framework Jasmine concurrently while doing this project, and an important lesson was the value of keeping things separate and independent. All I wanted from the image was two numbers, which could easily be supplied as parameters, thereby solving the mystery of the "white screen of death".
const BASE_WIDTH = 800;
const BASE_HEIGHT = 600;
...
window.addEventListener("DOMContentLoaded", (event) => setup(BASE_WIDTH, BASE_HEIGHT, event));
window.addEventListener("unload", cleanup);
window.addEventListener("resize", resizeListener);
An even less obvious type of event are those required to write concurrent JavaScript, which I'll digress into briefly here.
The Medium is the Message
Among the nice things about learning to program by developing games is it brings concurrency to life.
Multithreading has been added to JavaScript via Web Workers, and distributed computing via WebSockets and Service Workers.
These are all triggered by an event type called "message", adding a style of programming known as the actor model, which though fairly easy once you go "Aha!", involves quite a learning curve for anyone schooled in only OOP and FP.
Alan Kay, who coined the term object-oriented programming, saw messaging as a core part of the concept, which sadly got completely forgotten by the currently top-of-the-pops OOP languages.
Smalltalk's design — and existence — is due to the insight that everything we can describe can be represented by the recursive composition of a single kind of behavioral building block that hides its combination of state and process inside itself and can be dealt with only through the exchange of messages.
— The Early History Of Smalltalk, Alan Kay
Mercifully I tackled this after teaching myself Erlang, because I don't think I could have figured it out from the JavaScript exlanations I've seen.
Step 1 is what Erlang calls spawning a process, which with JavaScript is done by:
const stateWorker = new Worker("state-loop.js");
What Erlang does with ProcessID ! Message, JavaScript does with
stateWorker.postMessage(request)
I've called the code run by the worker a loop to follow Erlang convention where to keep processes alive to handle repeated
messages, they need to be written as a recursive loop. JavaScript workers automagically run as infinite listening loops which
carry on running until stateWorker.terminate()
is called.
The file loaded by the Worker corresponds to an Erlang receive pattern1 -> action1, pattern2 -> action2, ... end
block.
this.addEventListener("message", function(event) {
let reply;
case (event.data.type) {
"type1":
reply = ...;
this.postMessage(reply); // if a reply is needed
break;
"type2":
reply = ...
....
}
});
Making the message contained in event.data an object with an attributed called type is my own convention. A big lesson from Erlang's OTP patterns is that judicious choice of the compound data structure used as the message and naming conventions creates a powerful DSL.
Erlang's OTP uses the convention of making its typecall if the listening loop needs to reply, or cast if the request only involves changing the loop state. In this example, messages saying the left or right arrow have been pressed involve changing local variables, making them casts in Erlang terminology. Pressing the space bar or up arrow, on the other hand, require sound effects which the worker thread can't do.
A early mistake I made learning this was I sent an object to the worker thread containing a pointer to a binary blob (a sound buffer, but an image would have been as bad). Thereby I discovered an important subtlety is that the main file sends the worker a structured clone, not a reference, so trying to share binary data either doesn't work or slows things down.
Long story short, limit the data communicated between the worker and main threads to strings and numbers, no references.
Replies from the worker are received as events by a listener attached to the worker:
function stateWorkerListener(event) {
... do something with event.data ...
}
stateWorker.addEventListener("message", stateWorkerListener);
Whereas modules and their client files can share globals via their shared window root object, a mantra of this style of programming is shared nothing.
This required quite a lot of refactoring when I decided to move the physics engine portion of the game — the relatively maths heavy job of iterating through a list of sprites to update their positions, check for collissions, and filter out dead sprites — by what in Erlang terminology would be called spawning a process, and JavaScript calls instantiating a Worker.
The main script communicates with where request acts as arguments which callback function spritesUpdateListener(event) which would receive the result from in event.data
The sprites-updates.js file would follow this template:
One of the advantages of this is encourages modularisation. Another is it makes better use of modern hardware. With even cellphones today being multicore computers, it frees the main thread to do animation while other processors do trigonometry etc.
Step 2. Writing Handlers
Testing events
I started this project before learning test framework Jasmine, which turned into a lesson of the importance of test-first development.
Putting a block like this near the top of the file
const BASE_WIDTH = 800;
const BASE_HEIGHT = 600;
const THRUST_SPEED = 0.1;
const RECOIL = -0.05;
const ROTATE_RATE = 60;
const MISSILE_SPEED = 4;
is known as single point of control, a good design principle. A bad habit I got into, however, was then using these constants within functions, hitting a snag with Jasmine that it refuses to see globally defined constants or variables, unless they've been attached to the window object.
Though it got me cursing at first, I realised this was an important lesson on modularity: making assumptions about things outside a function's local scope is dangerous.
While there are a lot of addEventListeners attached to various targets, the number of handlers is fairly small.
I managed to abstract all the user interface handlers down to uiListener(event). I treat the event object as a pattern to be matched with a responding action, making its template what HTDP would call an enumeration.
For this I used JavaScript's switch block — of which I ended up using two in uiListener: the first matches the type of event — key or ponter up or down — and if it was a left, right, up or space button, which for pointer events requires id of the target. Whether it's left, right, up or space is then matched in the second switch block.
From an Erlang perspective, JavaScript pattern -> action code looks very long winded, requiring several switch blocks as in addEventListeners for stuff that Erlang's more sophisticated pattern matching and guards could do in one.
I've seen some JavaScript stylists advocating avoiding switch statements in
favour of lots of if (predicate1) {...} else if (predicate2) {...} else if...
, which I personally find
uglier and more prone to bugs.
A gotcha in JavaScript is its switch statements are fall through, which means that unless you end a
case
stanza with break;
or return;
, it continues to check if it matches further
patterns.
The first switch
block in uiListener uses break since I want to continue to the second block. There
I can use return since that pattern has been actioned.
A JSDoc gotcha that tripped me was to try and tag uiListener as @callback
instead of @function
, which
resulted in it getting ommited from the documentation. Presumably @callback
is an alternative to
@param
to only be used when the argument is a callback.
While I had little difficulty in getting the four user input keys to work, pressing any keys not listened to caused the programme
to freeze until I discovered that, counter-intuitively, the default
statement should be
event.preventDefault();
.
Another challenge was getting the browser to open a debugging console with F12 — which stopped working after keyboard
events were captured by my own function. The trick here was to write a case statement forwarding this key event
back to the document. To be fancy, I wrote event.target.dispatchEvent(event);
rather than
document.dispatchEvent(event);
just to test what the event.target property holds.
3. The main/game/listening loop
This is a function that calls itself recursively — so it never returns anything since it's an infinite loop. In Erlang, it would have a parameter called state which it would update and pass back to itself.
In JavaScript, the loop is initially called and then repeatedly recursively called via Window.requestAnimationFrame(callback) to set the rate the canvas is redrawn for animation to 60/second irrespective of the hardware (thereby avoiding a problem old video games have of running unplayably quickly because processor speeds have increased).
function loop() {
...
window.requestAnimationFrame(loop);
}
Testing
Testing such programs appears even harder because without the interaction there appears to be no program to speak of,
but automating the testing of interactive programs is especially challenging. Developing clean, well-tested interactive
programs therefore seems especially daunting to beginners.
—
How to Design Worlds
Since I did writing tests last instead of first, I'm currently refactoring my code since Jasmine refuses to let functions it tests see variables which weren't passed to them as arguments, and I used a lot of global variables.
Step 1 is to download the latest release. Unziping it produces something like:
./
├── lib/
│ ├── jasmine-3.6.0/jasmine_favicon.png
│ ├── jasmine-3.6.0/jasmine.js
│ ├── jasmine-3.6.0/jasmine-html.js
│ ├── jasmine-3.6.0/jasmine.css
│ └── jasmine-3.6.0/boot.js
├── SpecRunner.html
├── src/
│ ├── Player.js
│ └── Song.js
└── spec/
. ├── PlayerSpec.js
. └── SpecHelper.js
Though I probably should have a lib subdirectory (modularising game1.js
to separate and abstract the generic parts is on my todo list), I've decided to put all the necessary testing files into
one subdirectory, ./test
. I don't like the Jasmine convention of using ./spec
since I feel
specification and testing are not the same thing.
I've copied all the files in lib/jasmine-3.6.0/
to ./test
, along with SpecRunner.html
which I've renamed index.html
to make the report accessible by pointing the browser to the game's URL +
/test
.
A thing that tripped me up was following the standard way of declaring canvas
const canvas = document.querySelector("#board");
resulted in a global constant Jasmine refused to either let functions it was testing see or get replaced. The solution was to attach all HTML elements I wanted to make global to the window object
window.canvas = document.querySelector("#board");
which could then be mocked in Jasemin tests with window.canvas = {width: 800, height: 600};
Documenting
Most languages come with a large collection of abstractions. Some are contributions by the language design team;
others are added by programmers who use the language. To enable effective reuse of these abstractions, their creators
must supply the appropriate pieces of documentation — a purpose statement, a signature, and
good examples — and programmers use them to apply abstractions.
After testing, the next hardest part fro me has been getting to grips with JSDoc.
I've also tried to follow the Google JavaScript Style Guide, with the exception of ignoring its views of trailing commas since I find leading commas far better.

— From Mozilla's
Web audio concepts and usage guide.
Web APIs
Frontend web development boils down to familiarisation with the bewildering choice of Web APIs available, and the goal of this first game was to learn a minimal subset to get animation, sound, and user interaction working.
Invariably there are at least four ways of doing anything with JavaScript, and guessing the correct one involves knowing whether it is old or new, good or bad, functional or object-oriented, synchronous or asynchronous, block or function scope...
Achieving a desired goal requires an encyclopaedic knowledge of many objects and their properties, events and their handlers, and methods and their parameters — mercifully MDN is an excellent reference.
These are the ones I've settled on for now. Making the game mobile friendly involved learning yet another Web API, Touch Events, which I decided not to add the diagram below since it was too crowded already.
I've attempted to draw a hierarchy of the objects I've used, though in JavaScript that's not easy.
For instance, though Document is a child of Window, and CanvasRenderingContext2D of HTMLCanvasElement etc,
coding convention is to treat each as a separate object.
AudioContext
is initially addressed as a child of Window since it's the global, root object.
├── DOM
│ ├── Window
│ │ ├── Properties
│ │ │ ├── innerWidth
│ │ │ └── innerHeight
│ │ ├── Events
│ │ │ ├── DOMContentLoaded
│ │ │ ├── unload
│ │ │ └── resize
│ │ └── Methods
│ │ . └── requestAnimationFrame()
│ └── Document
│ . ├── Events
│ . │ ├── keydown
│ . │ ├── keyup
│ . │ ├── pointerdown
│ . │ └── pointerup
│ . └── Methods
│ . . └── querySelector()
The entry point of my programme introduced me two notorious horrors of Javascript: the
Pyramid of Doom (also known as Callback Hell
);
and the White Screen of Death
, neither problem I've entirely solved.
I toyed with putting the code below into a function called init(), but decided to simply leave it in the body of
the script because making it a separate function didn't DRY
or KISS anything. Furthermore, placing initialisation steps in a
block starting with window.addEventListener("DOMContentLoaded", ...
seems more in keeping with
event-driven programming than creating an extraneous function.
window.addEventListener("DOMContentLoaded", async function (event1) {
await backgroundImage.addEventListener("load", function (event2) {
resize();
sprites[0] = createSpaceship();
for (let rock = 1; rock <= 13; rock++) {
sprites[rock] = createAsteroid();
}
window.addEventListener("resize", resize);
window.requestAnimationFrame(loop);
});
});
A problem the above code addresses is I want my website to have responsive design in that the board (ie canvas object) should use all the available screen real estate. To calculate this, the programme needs window.innerWidth and window.innerHeight, which if used before the window has completed loading, will be undefined.
The base size (ie scale = 1.0) is provided by the width and height of the background image, which if read before the graphic file has finished downloading will be undefined.
A pitfall most novices will fall into is that, without care, JavaScript will produce a garbage value for scale
using undefined
for its calculation which canvas won't draw, leading to the dreaded White Screen of Death
with no error messages or clues on the console.
Before unravelling the above code, lets look at the new way, promises, using fetch which I've written the function to download sound files with:
function loadSound(url, audioNode) {
fetch(url)
.then((response) => response.arrayBuffer())
.then((buffer) => audioCtx.decodeAudioData(buffer))
.then((decodedData) => audioNode.buffer = decodedData);
}
Three asynchronous processes which are contingent on each other — the buffer property of the audio node needs data
decoded by the audio context, which in turn depends on a sound file that has to have finished downloading.
The .then(...)
syntax lets us chain these three steps together in sequential steps, hiding the mind-bending concurrency.
The old way of doing this was to nest each subsequent asynchronous step in the callback of its predecessor, which for many contingent steps
would lead to very deeply nested, ugly code — the Pyramid of Death
.
Mercifully, the initial window then background image loaded before launchign the loop
chain only involves two steps,
so its pyramid of doom isn't very high. Preventing a white screen of death
, however, involved the additional step of
invoking JavaScript's async function (...) {... await ...} combination to avoid the loop getting started before scale
was set correctly.
A fourth event, resize, is attached to the window so the user can make the board bigger or smaller by adjusting the size of their browser, or changing the orientation of their phone.
How to stop?
Frameworks which have an init() or setup() starting point tend to have a stop(), terminate(), or cleanup() function to call at the end. I discovered I needed something like that after testing my site on a mobile phone and discovering that when I closed a window but didn't shut down the browser, the sound continued. I attempted to fix this with yet another event handler.
Again, in keeping with my home brewed event-driven programming style, everything goes into a main body code stanza
starting
with window.addEventListener("unload",...
rather than a function.
window.addEventListener("unload", function (event) {
backgroundSound.stop();
thrustSound.stop();
missileSound.stop();
explosionSound.stop();
});
State
In Erlang, the recursive loop would have an argument — usually a compound data structure containing the various things commonly called a state — which the body of the loop would alter according to messages sent to it by handlers and then call itself with the new value.
Here, instead of what Erlang calls a mailbox and the C-family would call a message queue, messaging is done by the handlers mutating global variables which the loop reads each iteration.
inputStates is the core messaging mechanism the handlers use to communicate to the game loop. All the propertis of inputStates (with the exception of a sound buffer) are booleans, and I've followed Google's style of using a isFoo convention. For some, I've gotten into the habit of using snake case, so find the JavaScript convention of camelCase and PascalCase a bit alien, but am getting the hang of it.
Another core state variable is sprites, a list (or
array as JavaScript calls lists) of sprite elements. In
this game, I've made a convention that the spaceship sprite (which somethimes mutates briefly into an explosion
when it collides with an asteroid) can be accessed as sprites[0]
.
List processing
A really powerful idea from functional programming (FP to its friends) is breaking problems down iterating over lists, applying the same function to each element depending on which of three categories the task at hand falls into:
Map and filter can be built out of reduce, which in pure functional programming languages is usually called foldr (JavaScript has for purists).
Since mutation is taboo in FP, the above traditional list processors all produce a new list. If we don't want a new list (which for traditional functional programming languages would be for printing data from each list element on a screen), we can use forEach, which makes all the whizing stuff on the screen with this one line of code:
sprites.forEach(function (sprite) {draw(sprite); nextTick(sprite);});
draw(sprite) obviously belongs in forEach since it does the GUI equivalent of a print statement, but putting nextTick(sprite) there would be frowned on by FP purists since the position and other values of each sprite get changed. Since JavaScript encourages mutations and changing the properties of objects referenced in the array rather than removing and appending new ones is a lot less work for the programmer and computer, I've gone that route.
Drawing and updating
As Mozilla's Basic Animations
guide explains, the ...
above expands into broadly three steps:
- Clear the canvas with ctx.clearRect() and create a fresh background.
- Iteratively draw each sprite in these steps:
- Save the canvas state with ctx.save();
- Move to centre of rotation ctx.translate(x, y);
- Swivel image ctx.rotate(angle);
- ctx.drawImage(image, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight);
- Restore the canvas state with ctx.restore();
- Update the position of each sprite before they're drawn again to make them move.
Writing nextTick got me to dust off the trigonometry and physics I learned way back in the last century. While my goal was to keep the game as simple as possible so as to focus on learning JavaScript and its related tools, I couldn't help making the spaceship recoil a bit when it fires a missile to force the player to use the thruster... I was also tempted to make the asteroids bounce off each other like billiard balls, but I'll save that for a future version.
In conclusion, writing this game taught me a lot. Besides encountering many of the problems with JavaScript and hopefully finding ways to overcome them — a neverending quest I suspect.
this document will already make most readers say tl;dr so I'll rather proceed to my next project, creating a dungeon crawler specifically designed for mobile phones, with only touch user intput.


Instructions:
The goal of KongSweeper is to uncover all the squares that don't contain TNT without being blown up.
Select your difficulty, enter your name and add the width of your grid (between 5 and 30 squares).
Left click to reveal a square.
Right click to flag a possible bomb.
The counter will tell you how many flags remain.
Clear all the bombs in the fastest time and earn your spot on the leaderboard!


Ilo Ilo - Anthony Chan That Girl in Pinafore - Chia Yee Wai 881 - Royston Tan Comedy Drama Independent
Movie Info Rating Genre Directed By Written By In Theatres Runtime Average Rating User Reviews Rating: Submit
User Reviews


Back
Developer
Debug
Grid
Show frames per second
Flash repainted area
Flash repainted area
Log slow animations
Show time to load
Remote Debugging
Wi-Fi output in adb
Bluetooth output in adb
Contacts debugging output in adb
Console enabled
Software home button enabled
Gaia debug traces
Launch FTU
Keyboard Layouts
Zhuyin
Traditional Chinese
Pinyin
Simplified Chinese


@import _root_.musicWebApp.models.{Recording, Performer, Soloist, Ensemble, Conductor} @import _root_.musicWebApp.controllers.OptionalPerformerData @import helper._ @(ps: Seq[Performer], rs: Seq[Recording], searchForm: Form[OptionalPerformerData])(implicit messages: Messages) @implicitField = @{ FieldConstructor(myFieldConstructorTemplate.f) } @main("Classic Music Service") {
--- No Performers ---
You cannot delete a Performer as long as Recordings are assigned to him. First delete the Recordings of the Performer. Then you can delete the Performer.


--- title: Cards page-title: Cards done: true --- {% assign photos = site.data.photos | where: "horizontal", true %}
This is a longer card with supporting text below as a natural lead-in to additional content. This content is a little bit longer.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer posuere erat a ante.
This card has supporting text below as a natural lead-in to additional content.
Last updated 3 mins ago
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer posuere erat.
This card has supporting text below as a natural lead-in to additional content.
Last updated 3 mins ago
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer posuere erat a ante.
This is a wider card with supporting text below as a natural lead-in to additional content. This card has even longer content than the first to show that equal height action.
Last updated 3 mins ago


why is the output from the current sensor (Yhdc Current Transformer: SCT-013-000) modulated sine wave ?
as bellow : this is just pure analog readings from the arduino after implementing the 2.5V offset
and here is the zoomed version:
isn't it supposed to be a pure sine wave as ?
I want to implement another project using the same methodology so I want to make sure that what I am doing is correct.thanks
Re: why does the output from the current signal have a modulated sinewave
What are the units on the timebase? It looks like you've got two sine waves there, one about 25x the frequency of the other. If I assume the one with the big swings is at 50Hz, then you've got some ~2Hz signal superimposed on that, with a peak-to-peak of about 20 units. What does your multimeter read when set to AC, while measuring the 2.5V offset rail? What component values have you used to build your 2.5V offset rail?
There's a thread on noise that might be helpful here: http://openenergymonitor.org/emon/node/10111
Re: why does the output from the current signal have a modulated sinewave
my sampling frequency was 5000 samples per second
actually here is the FFT
the fundemental frequency is 50 Hz and then there is some other frequency components at 100 Hz and 150 Hz
(the x axis is the frequency in Hz)
does that explain ?
I am using 470 Khz and 10 uF
it reads 0 volt
Re: why does the output from the current signal have a modulated sinewave
You can get this sort of 'beat' effect if your sampling frequency is not an exact multiple of the measured frequency. The Arduino free running ADC sampling interval is 104us. This means that the sampling point will slowly move on the sampled 50Hz sine wave.
But the effect (+/- 10 digits) is quite big and I do not think this is the real reason....
Can you tell us more about your code? Are you using the ADC in free running mode?
BR, Jörg.
Re: why does the output from the current signal have a modulated sinewave
Actually, given the very low frequency of the secondary wave (2 Hz), you might be better setting the voltmeter to DC and see if stays steady. Do you have access to a scope? Like in that thread referenced above, if you can't seen any sign of the noise in the signal, try looking for it on Vcc or AREF.
Re: why does the output from the current signal have a modulated sinewave
You can get this sort of 'beat' effect if your sampling frequency is not an exact multiple of the measured frequency.
It's a nice theory though... and goes a long way to explaining the incredibly low frequency of the "noise". Pursuing how the code is using the ADC sounds like a good plan to me; far more likely to find a 2Hz component in there then you would on a scope.
Re: why does the output from the current signal have a modulated sinewave
hey @JBecker
guys, what 2 Hz frequency are you talking about ? I can't see 2 Hz component in the frequency analysis? there is only 100 Hz (2nd harmonic) and 150 Hz (3rd harmonic )
check the FFT picture in my comment above
my code is using free running mode ADC and a timer that allows you to take samples in pre specified intervals(you can choose the sampling frequency) and my sampling rate was 5000 which is a multiple of 50 , I don't think this is the problem
I use sdFat library, it has a good example on this, refer to:
https://github.com/greiman/SdFat
hey friend @dBC
voltmeter DC stays steady, . and I got back from office now and I don't have an access to scope but when I tested the signal, it was okay and it didn't have any significant noise
I believe that, the waveform looks so because it has this 100 Hz and 150 Hz components which are called the second the the third harmonics:
http://www.electronics-tutorials.ws/accircuits/harmonics.html
Re: why does the output from the current signal have a modulated sinewave
Higher harmonics cannot be responsible for a low frequency component, no way. Harmonics will change the shape of the basic frequency sine wave (so that it is no pure sine wave any more) but they will not 'produce' lower harmonics. Low harmonics can be a result of frequency 'mixing', in this case mixing of the measured signal and the sampling frequency.
.....and it is not only a theory:-) I have been doing this stuff since 20 years and this is what you always get if your sampling frequency does not 'fit' to the sampled signal (and this has nothing to do with the Nyquist frequency). I think this has already discussed in a thread about the necessity for (or advantages of) a PLL which will adjust the sampling frequency to the measured signal.
BR, Jörg.
Re: why does the output from the current signal have a modulated sinewave
could you explain to me how did you know that there is lower harmonics ? this 2 Hz as you say.
Sorry I am not super good at signal processing : )
and it would be interesting if you could provide me with a link for PLL
thanks
Re: why does the output from the current signal have a modulated sinewave
Good question as i did not do an FFT and your FFT does not show the 2Hz component. But I (or better dBC!) can actually 'see' this component in your pictures. If you 'add' a 2Hz sine (with ~20 units peak-to-peak) to a 50Hz sine (with ~140 units peak-to-peak) the picture will just look more or less like what you showed us.
PLL: please use PLL for searching in this forum and you will get a number of results.
Martin's sketch with PLL is discussed here: http://openenergymonitor.org/emon/node/1535
BR, Jörg.
Re: why does the output from the current signal have a modulated sinewave
Sabirmgd,
I have deleted 14 copies of a message that you posted in this thread. You waste everyone's time doing that, and it was only because you did not look at your browser window to see that your message had been held for moderation. It is not the Internet that is sh****. Please be patient in the future.
Re: why does the output from the current signal have a modulated sinewave
I am sorry for wasting your time, Robert.
I just had to write my LONG answer over and over again every time I find it not posted yet. I didn't notice that my message had been held for moderation.
yet my internet is sh****
my apologies.
Re: why does the output from the current signal have a modulated sinewave
and my sampling rate was 5000 which is a multiple of 50
Is your 50Hz coming from a signal generator, or from the grid? If from the grid, then remember you're chasing a moving target there... hence the PLL suggestion. Here's what my grid frequency looks like over the last week:
And here's a zoom-in on that dip on the morning of March 21st:
Re: why does the output from the current signal have a modulated sinewave
Sabirmgd, can you explain what you mean by "voltage readings from Arduino". Are these sampled values from the ADC (within the range 0 to 1023), or are you measuring an analogue signal with some other system?
Re: why does the output from the current signal have a modulated sinewave
Just looking at those numbers: "my sampling rate was 5000"
Are you printing to serial output to get the values out of the Arduino? If you are, and you are not storing them in an array first, then your sample rate is not 5000 per second. And that is for two reasons: first, the serial output is slow; second, it doesn't tie up with what you are seeing.
What you are seeing is a sampling artefact. Your sample rate is not an exact sub-multiple of the mains frequency, therefore the samples do not happen at exactly the same point on the wave each time. This is what I get when, using a spreadsheet, I plot y=sin(sampleNo / 5.04 × 2 × π)
Re: why does the output from the current signal have a modulated sinewave
Fully agreed, Robert! This is more or less what I said above. But as long as we are not given the complete code, it is not clear if this is the real reason.
Jörg.
Re: why does the output from the current signal have a modulated sinewave
@dBC, its not from a function generator its from an air conditioner which is a moving target. Most Probably I should consider PLL
hey @calypso_rae, "voltage readings from Arduino" means the sampled values from the ADC (within the range 0 to 1023). sorry the term was not accurate.
hey, @Robert Wall. our beloved admin : )
I totally got your point. its true the serial port is very slow I struggled because of its speed when I was trying to make a program in C#.net to plot the real time data.
but NO, I am storing them in a memory card first using this library which allows you to exactly set your sampling rate
https://github.com/greiman/SdFat
No serial port involved in the experiment
Re: why does the output from the current signal have a modulated sinewave
Look at my equation then compare my graph with Sabirmgd's. The relative frequencies are similar, the modulation amplitude is similar. Does that not tell us that the real sample rate is about 5 samples per cycle, not 100?
We need the real timing of the main loop to get any further, the complete sketch would be fine.
Re: why does the output from the current signal have a modulated sinewave
The same argument applies: writing a serial card is slow. I suggest you read the millisecond clock, run the loop (say) 10000 times and read the clock again, then you will know the real sample rate. I don't believe it is 100 samples per cycle simply because the maths of the "modulated" output does not fit the graph you published in your first post above.
Re: why does the output from the current signal have a modulated sinewave
here is the sketch
Re: why does the output from the current signal have a modulated sinewave
I don't have an Arduino, so I cannot run your code to test it. Does the code give any errors?
What sort of power supply are you using for your Arduino? Have you checked that the 5 V is clean & stable, with no ripple of any sort on it?
Re: why does the output from the current signal have a modulated sinewave
a q: what are you using?
for this test I used just the USB for the power . the code doesn't give any error
the 5 volt is stable ( when I measure it using digital millimeter) , it doesn't change. or that doesn't indicate ?
Re: why does the output from the current signal have a modulated sinewave
It was worth asking.
What do you see when you change the sample rate to a value that is not exactly (or supposedly so) a multiple of line frequency? Say 4985 samples/sec?
It would also be useful to expand the trace time-wise so that you can see individual samples. Do this where the "modulating" wave is at a positive peak and at a negative peak.
Re: why does the output from the current signal have a modulated sinewave
The graphically-displayed sample values in the initial post only appear to only change approx 15 times per mains cycle, so that would be a sample rate of around 750 samples/second. Maybe this is just an effect of display resolution, but I thought it worth pointing out.
Re: why does the output from the current signal have a modulated sinewave
Did you see my spreadsheet graph? You can't get the output that's in the top post unless you drop the sample rate to about 5 per cycle.
It's a matter of getting two samples to straddle the peak, they must be far enough apart for each to be at about 80% of the amplitude of the wave to get the "depth of modulation" we see.
cos-1(0.8) = 37°, that means they are 74° apart, or 4.86 samples per cycle.
Re: why does the output from the current signal have a modulated sinewave
Yes, I entirely agree with your deductions Robert. I was just pointing out that the displayed waveform appears to show distinct steps that could be attributed to a much slower sampling rate than the claimed rate of 5000 per second (or 100 samples per mains cycle at 50 Hz).
The bottom graph in the initial post is presented as for a "pure sine wave". However, the measurements in question are being taken via the ADC which generates a stream of samples, not a "pure" waveform.
Re: why does the output from the current signal have a modulated sinewave
before running another experiment with a sampling rate that is 4985 samples/sec , I want to confirm with you that the sampling rate is 5000 Hz, or 100 samples for each mean cycle.
we can see that obvious from the graph, for 500 samples, we get 5 complete cycles which is 100 samples for each main cycle.
I also attached the sampling file which is taking the reading from arduino.
Re: why does the output from the current signal have a modulated sinewave
Could it be that the waveform is 'real' for that sort of load? The waveform is not a pure sine, so it is not a purely resistive load (an air conditioner is for sure not purely resistive). And the wobbling might be due to some sort of speed or power regulation?
BR, Jörg.
Re: why does the output from the current signal have a modulated sinewave
Could it be that the waveform is 'real' for that sort of load?
this is the first think I should thought of ! that is true. here is the signal using the scope:
anyway thank you guys I really got a lot from the discussion.
Re: why does the output from the current signal have a modulated sinewave
Here are some results as collected using an emonTx V2. The AC voltage source is a standard chassis-type mains transformer. The sketch is a cut-down version of my RawSamplesTool. This version, voltageSamples.ino, simply collects and stores a specified number of voltage samples, then writes them to Serial.
When running at its maximum rate, there are approx 180 samples / mains cycle, so each sample takes 111 us. This sketch uses analogRead() which appears to be approx 7 us slower than when the ADC is controlled by low-level commands. Using most of the available RAM, just over 4 waveforms can be stored (750 samples' worth). When displayed on a spreadsheet, this max rate data looks like voltageSamples_maxRate.jpg
By adding a delay after each sample is taken, the sampling rate can be reduced. When the sampling rate is reduced to approx 1000 samples per second (only 20 samples per mains cycle), some fluctuations can be seen as in voltageSamples_1000perSec.jpg
By adding 4004 us of delay per sample, there are only 4.85 samples per mains cycle. This appears to show the kind of modulation as Robert has calculated. In voltageSamples_4pt85perMainsCycle.jpg, I've reduced the number of samples to 100
The modulation that is seen in these graphs is presumably just an artifact of the way that these sample values are displayed. If they were correctly interpreted as being samples of a 50 Hz waveform, then a true unmodulated 50Hz waveform would appear. Unfortunately, a standard graphical package does not include this filtering facility.
Re: why does the output from the current signal have a modulated sinewave
Calypso,
Oh that is great!
I think my problem (or actually its not a problem ) was the air conditioner that I was monitoring. It produces this kind of sinewaves ( the modulated one as in the first post)
With your post confirming that, I should be getting a pure sine wave if my signal source is really producing a sinewave.
Re: why does the output from the current signal have a modulated sinewave
My post was to show that a clean sine wave, when sampled slowly, can appear to be modulated when displayed using simple graphical means, just as Robert has calculated.
Have you tried monitoring and displaying your mains voltage, as I have done, rather than the current drawn by your air conditioner?
Re: why does the output from the current signal have a modulated sinewave
I got your point.
In fact no, my aim basically is to monitor the current from washing machines in a laundry shop. I was using the air conditioner just because its in the lab.
Re: why does the output from the current signal have a modulated sinewave
Try monitoring an electric convector heater, or a kettle. The current waveform's shape will be almost identical to the voltage waveform, which in turn should be close to sine wave. But as you can see from Robin's trace, in the UK we get "flat topping" where the peaks are flattened. That's NOT a problem with sampling or recording, my analogue oscilloscope shows exactly the same shape.
Re: why does the output from the current signal have a modulated sinewave
analogRead() which appears to be approx 7 us slower than when the ADC is controlled by low-level commands.
I suspect that's how long it takes to decide which pin to sample. It needs to map from Arduino-land pin numbering scheme to AVR-land port/pin numbering scheme.
Re: why does the output from the current signal have a modulated sinewave
Try monitoring an electric convector heater, or a kettle.
I will be monitoring a kettle to review next experiment.
I think the main advantage of using low level commands or interrupts is that, it provides you with "continues data logging" as in free running mode the flag will be (lets say true) to get a new analog reading whenever the previous reading is captured and stored ADCH and ADCL
Just mentioning the sampling and sampling frequency, what is the maximum sampling rate I can get using an arduino and a wifi or eithernet module? Or lets say emonTxV2 and RPi and emoncms( with wifi ) ? Does anyone have an experience?
I am thinking to move from this memory card to cloud base monitoring.
Re: why does the output from the current signal have a modulated sinewave
The fastest way to obtain samples from the ADC is to have it in free-running mode. The ADC is then running at its maximum rate and produces a sample every 104 us. The program needs to direct the ADC to the appropriate channel in advance so that the ADC sub-processor will know what to do next when the in-progress conversion has finished.
A slightly less fast approach is to initiate the next conversion from with an ISR which springs into life whenever a conversion has finished.
The easiest approach is for the main program to wait until the conversion has been completed. The program then does something with the resulting value and in due course initiates the next conversion. This is how analogRead() works.
With either of the first two schemes, the main program in loop() can continue to do things while each ADC conversion is in progress. These interrupt-based schemes therefore have the capability of being significantly faster than the analogRead() approach.
Having said which, analogRead() does a perfectly good job for most applications. For continuous monitoring of several ADC channels, it makes sense to use an interrupt-based sampling scheme so that the sampling rate can be higher. When the ADC is in free running mode, it can service all six analog ports 32 times within each 50 Hz mains cycle.
The rate at which datalogging via RF takes place is not related to the ADC sampling rate. It can be as fast as you wish. Most monitoring programs transmit datalog data every few seconds, typically every 5 or 10 seconds. If the program goes to sleep between transmissions, or attends to each channel in turn so there are breaks in service, it is termed "discrete" monitoring. If all channels are monitored at all times, it is termed "continuous monitoring".
Sorry if this is off topic.


@JvmStatic fun cancelCallbacks(): Unit
Cancel any in-flight CustomerSession operations. Their callback listeners will not be called.
It will not clear the singleton CustomerSession instance.
It is not necessary to call initCustomerSession after calling cancelCallbacks.


2020 Range Rover Evoque review: P200 R-Dynamic S
Land Rover’s fashionable 2020 Range Rover Evoque carries a designer price tag even in entry-level form, but it’s posher, roomier and more refined in second-generation form.
by Jez SpinksRating: 8.0
$65,650 Mrlp
- Fuel Economy
8.1L - Engine Power
147kW - CO2 Emissions
184g - ANCAP Rating
5Stars
Looking for a deal on this car?
Pros and Cons
Pros
- Superb ride on country roads
- Properly posh interior with excellent materials quality
- Quiet cabin on the move
- Multiple customisation options including sustainable materials
- Off-road credentials
Cons
- Pricey and with many options that should be standard
- Gearbox hesitations on take-off
- Tardy stop-start system
- Urban ride not as smooth on 20-inch wheels
- No wireless phone charging
- shares
It’s hard to believe it is nearly 12 years since the Range Rover Evoque was previewed by the show-stopping LRX concept. This was Land Rover’s equivalent of the Audi TT, and it similarly went into production virtually unchanged.
The Evoque went on to become a sales sensation and spawn a raft of designer SUVs from luxury brands from Audi (Q2) to Volvo (XC40).
The bad news is that the Evoque now carries a proper designer price tag with the arrival of the second-generation version. Whereas the original was once available for just below $50,000, the latest Evoque costs from $62,670.
That’s for the P200 S we’re testing here, which kicks off yet another mind-bogglingly lengthy list of Evoque variants: 26.
Our test car is specifically the $65,650 2020 Range Rover Evoque P200 R-Dynamic S that garnishes the exterior with Dark Atlas scripts and grille, Burnished Copper exhaust tips, side vents and bonnet louvres, a body-coloured lower front bumper, and gloss-black side mirrors.
Customisation doesn’t stop there, as further options include a black contrast roof ($970), a Black Exterior Pack ($1680), and 20-inch wheels ($2120) instead of the standard 18s.
They’re natural options for a model that has become something of a style icon, and it’s hardly surprising the overall design of the Evoque MkII is an evolution considering its predecessor’s commercial success.
Yet, while the Evoque has influenced other Land Rover designs, this time it’s another Range Rover that provides some inspiration in return. The Evoque’s flush door handles and headlights are directly from the Velar.
Climb into the Evoque – after pressing the key fob to smoothly eject the door handles – and bigger changes are afoot.
While there’s another evolutionary design link for the interior with the indented mid-dash touchscreen display, Land Rover has dialled up the posh factor. Pliable surfaces seem to be almost everywhere you touch in the cabin, including the lower sections of the doors that are typically hard plastic in premium compact SUV rivals.
Many of the materials used for the dash, doors and roof-lining also look suitably expensive. S and SE models come with grained leather upholstery as standard, in a choice of two colours, and they’re comfortable and supportive. Windsor leather is available as an option or choose to have your seats with a sustainable twist.
A Eucalyptus textile made from natural fibres paired with non-animal-derived Ultrafabric is a no-cost option, or for $4188 there’s a Danish wool blend (Kvadrat) matched with a Dinamica suedecloth made from 53 recycled plastic bottles. Land Rover claims up to 33kg of natural or recycled material is used in every Evoque.
More Velar nods come in the form of the steering wheel’s capacitive control pads, while the Touch Pro Duo dual-touchscreen set-up that debuted on that Rangie is available as an option on the Evoque.
Wireless charging, however, isn’t available even as an option or on higher trim grades.
In standard form, the Evoque’s lower gloss-black control panel features physical dials and touch buttons for heating/ventilation functions, and a smaller physical dial for volume control.
Whereas the Velar continues with a rotary controller, the Evoque moves to a conventional gear lever. (The former was a nice idea when it debuted on the 2008 Jaguar XF, but the latter is ergonomically and visually better.)
There are a couple of other ergonomic improvements up front. The door handles have been positioned further forward, and the dual centre console cupholders are now positioned side by side rather than in a line (making it less awkward if both front occupants reach for their drinks at the same time). The console bin has also increased in size, complementing the sizeable door pockets.
There’s minimal change to the Evoque’s 4.4m length, but Land Rover has squeezed an extra 20mm of knee room into the rear seat – and it’s noticeable. Head room remains plentiful, leaving only toe space that could be more generous. Back-seaters also get ventilation, a centre armrest and good storage options.
An auto tailgate is among options you would expect to be standard, though at least boot space has increased, mainly in width. It’s only by 10 per cent, to 591L, but visually it seems to be a bigger difference.
You sit higher in the Evoque than many of its rivals, including the Lexus UX and Volvo XC40.
That provides for good visibility out front. Rear vision is quite narrow owing to the Evoque’s design, though if that becomes significantly obscured by piled-up luggage in the boot, there’s the option of Clearsight technology. With a flick of a switch, this turns your rear-view mirror into a video of the road behind (via a wide-angle camera built into the rear roof pod).
Seems fair enough that the Clearsight Rear View Mirror is an option (forming part of the Surround Camera), though there’s plenty of technology Land Rover charges for (in various bundle packs) that is standard on key rivals – including adaptive cruise control, blind-spot monitoring, keyless entry, and tyre pressure monitoring. There is speed-sign notification, front/rear parking sensors and lane-keep assist.
On the road, there’s increased refinement to match the upgraded plushness of the Evoque’s cabin. Whether you’re considering wind, tyre or engine noise, the Evoque is a quiet cruiser, even on more coarsely surfaced roads. And that’s despite our P200 S’s large optional wheels. The Range Rover’s country-road ride is also superb, feeling relaxed without getting wallowy.
An XC40 has a more absorbent urban ride, though sticking with the Evoque’s smaller standard wheels (or even no-cost-option 17s) might remove some of the lumpiness and thumpiness we experienced on our 20-inch-wheeled test car.
Those big tyres provide good grip even in damp conditions, though, even if the Evoque isn’t going to be the first choice for buyers seeking a keen driver’s kind of SUV. The steering’s lightness works more in its favour around town, while there’s inevitably some lean through corners, if not excessive, for this high-rider.
On the mention of which, if there’s a chance you may be looking to clear some obstacles, few premium compact SUVs are as well equipped to venture off-road. The Evoque comes standard with low-speed cruise control, a 600mm wading depth (up 100mm), and Terrain Response 2 that – either automatically or manually – adjusts for whatever particular surface is beneath the wheels.
You can even see beneath the front wheels by paying extra for Land Rover’s Ground View technology, which uses cameras on the side mirrors and grille to provide an x-ray-style vision of the path ahead via the central dash display – effectively making the bonnet ‘invisible’.
There are four engine options for the Evoque in S spec, including two turbo diesels. Our P200 badge means we have the lesser-powered 2.0-litre four-cylinder of two petrol options.
The 147kW/320Nm petrol doesn’t have the low-rev grunt of either diesels (430Nm D180/500Nm D240), in case towing is a consideration, though it is quicker. A more powerful P250 (183kW/365Nm) engine is available, but if you want significant performance, you’ll need the 221kW P300 available in SE or HSE guise, along with a budget in excess of $82,000.
Otherwise, there’s a perkiness to the Evoque P200’s initial acceleration and adequate pulling power for most buyers.
The nine-speed automatic is at its best when the Evoque is well up to speed, if guilty of sometimes hanging onto a gear too long, but it can stumble when taking off and the stop-start system is tardy when it comes to re-engaging the engine.
Our testing suggests the Evoque P200 isn’t great at conserving fuel, either, with an indicated 13.8L/100km – more than 50 per cent higher than the model’s official consumption of 8.1L/100km. Either that or the Evoque has a very pessimistic trip computer.
The Evoque is one of those vehicles that will sell purely on the basis of its design, with many buyers happy to overlook some questionable aspects of the model’s value – considering this P200 S not only costs more than some direct rivals, but doesn’t offer as much standard gear.
Yet, there is more substance to the baby Rangie second time around. It’s roomier and more luxurious inside, making it an SUV that could also be compared with models in the next segment up.
MORE: Evoque news, reviews, comparisons and videos
MORE: Everything Range Rover
Our Ratings Breakdown
Rating: 8
7.5 Performance
8.2 Ride Quality
7.9 Handling & Dynamics
8.4 Driver Technology
8.7 Interior Comfort & Packaging
8.0 Infotainment & Connectivity
7.1 Fuel Efficiency
8.5 Safety
7.0 Value for Money
8.4 Fit for Purpose
Our ratings explained
Looking for a deal on this car?
1
51
nextprevious
2020 Range Rover Evoque review: P200 R-Dynamic S


Nimbits supports many authentication processes including OAUTH, OpenID, and Google Authentication. The easiest way to read and write data to and from Nimbits is to use an Access Key, which you can create, change and delete at will
An access key allows you to grant read only access to data, or read / write access to all of your data points. To create a key, right click on the point you want to grant access to, or your user name at the top of the tree for global access.
You can have many access keys on your account that, when provided, tell nimbits what you can do. Access keys can be configured with global access, or limited to only being able to read from a single data point. Create an access key by logging into Nimbits and right clicking on your user name or a data point. From there you can enter your access key code, which can be any string or any length. This makes it easy to have a short url for posting to a low security point or sharing semi-private keys with others which you can easily revoke.
The Web services will also accept Google Account credentials using authentication tokens from Google or an android phone. We greatly simplify doing this with the nimbits SDK, which already has the code you need to use Google accounts to authenticate to the web services.
If you are a Java or .Net developer you can simply use the Nimbits SDK on the Download page. The SDK calls all of our web services exactly the way they are documented here, and they already have the authentication, and code you need to talk to a Nimbits Server.


Before Change
input_tensors = []
for input_key in sorted(x.keys()):
items = x[input_key]
if not isinstance(items, list):
items = [items]
for tensor in items:
dim = tensor.shape.as_list()[1]
if dim == 1:
input_tensors.append(tensor)
After Change
outputs_for_monotonicity = [[], []]
for monotonicities, inputs_for_units in self._rtl_structure:
if len(inputs_for_units) == 1:
inputs_for_units = inputs_for_units[0]
lattice_inputs = tf.gather(flattened_input, inputs_for_units, axis=1)
output_monotonicity = max(monotonicities)
// Call each lattice layer and store based on output monotonicy.
outputs_for_monotonicity[output_monotonicity].append(
self._lattice_layers[str(monotonicities)](lattice_inputs))


subspace billing server protocol proposal
version 1.3.1
<EMAIL_ADDRESS>all communication goes over a single tcp socket. messages are lines,
delimited by linefeed characters (ascii 10) (although servers and
clients should accept CR, LF, and CRLF). fields within a message are
delimited by colons (ascii 58). the first field is the type of the
message. each type has a fixed number of fields to expect, so the last
field can contain colons without confusing anything. integer values in
fields should be in decimal. all lines will be no more than 1023
characters in length (including LF). either side may discard lines
longer than that length if it receives them.
the game server will initiate a tcp connection to the billing server on
the agreed port.
(from now on, I'm going to get lazy, and call the game server "the
server", and the billing server "the biller". i'll use g->b and b->g to
describe the two directions.)
the protocol is versioned with a three-part number (major revision,
minor revision, patch). backwards compatbility is guaranteed when two
version differ only by the patch number. when two versions differ by a
major or minor revision number, all bets are off.
the server sends the protocol version that it speaks to the biller. if
the biller supports it (and everything else is ok), the biller can reply
successfully and a connection is established. if the biller doesn't
support the version requested (module the patch number), or if anything
else is wrong with the login, it should return failure and close the
connection. no further protocol version negociation takes places.
to login:
g->b: "CONNECT:version:swname:zonename:hostname:password"
version is the version of the protocol used. it should have three
numbers separated by dots (major, minor, patch). the current version
is at the top of this document.
swname is something idenifying the software used, like "asss 1.0.5".
zonename is the name of this zone, like "A Small Warzone".
hostname is where this zone is hosted, like "SSCX".
password is a password to authenticate this zone.
the response will either be this:
b->g: "CONNECTOK:swname:billername"
swname is something identifying the biller used, like "mybiller 0.29".
billername is a string identifying this biller network, like "SSC".
or
b->g: "CONNECTBAD:swname:billername:reason"
swname and billername are as above.
reason is something describing why the connection was refused, like
"bad password", or "wrong protocol version".
the biller will most likely close the connection after sending a
CONNECTBAD, but if it doesn't, the game server should.
the rest can only be used after a successful connection.
game sends:
g->b: "PLOGIN:pid:flag:name:pw:ip:macid:contid"
pid is the player id assigned to this player by the server.
flag is 0 for a normal login, 1 for "i want to create a new player".
name is the name that's trying to log in.
pw is the password he's using.
ip is the address he's connecting from (in dotted decimal).
macid is the standard machine id of the player.
contid is the id data from continuum players. if the player isn't
using cont, it should be empty. if the player is using cont, it will
be the cont id, encoded in 128 characters, using plain hex encoding
with lowercase letters.
biller responds with either:
b->g: "POK:pid:rtext:name:squad:billerid:usage:firstused"
pid is the player id that was passed in PLOGIN.
rtext is additional text that can be delivered to the client. if
there are no complications logging in, it should be empty.
name is the name assigned by the biller (the biller can change the
name of a player if desired).
squad is the player's squad.
billerid is an id number assigned by the billing server.
usage is the number of seconds that this player has ever been
connected to this biller.
firstused is a string describing when this named account was
created, in roughly this form: "1-2-1999 6:13:35"
or
b->g: "PBAD:pid:newname:rtext"
pid is the player id passed in PLOGIN.
newname is 1 if the requested name doesn't exist in the biller's
database and is available for creation. it is 0 otherwise.
rtext is some text describing the reason this login was denied.
::::: player registration (optional)
_before_ sending a POK, the biller can request registration information
by sending:
b->g: "WANTREG:pid"
pid is the pid for which registration information is requested.
the server may eventually respond:
g->b: "REGDATA:pid:data"
pid is the pid of the player whose information is being submitted.
data is hex-encoded binary data containing the registration
information. the format or length of this data is not specified in
this document, and may be client-specific.
the biller can send this any any time, but will typically send it right
after a PLOGINOK message:
b->g: "BNR:pid:banner"
pid is the pid of the player setting his banner.
banner is a 96-byte banner, encoded using standard hex encoding with
lowercase letters, so it will be 192 bytes long.
when a player sets his banner, the server will update the biller with:
g->b: "BNR:pid:banner"
pid the the pid of the player setting his banner.
banner is the new banner, encoded as above.
when a player enters an arena for the first time after logging in, the
server sends:
g->b: "PENTERARENA:pid"
when a player disconnects from the server, the server sends:
g->b: "PLEAVE:pid"
the biller can request that the server disconnect a player by sending:
b->g: "PKICK:pid:reason"
pid is the pid of the player to be kicked.
reason is some text describing the reason the player was kicked.
when a player sends a ?chat message, the server sends:
g->b: "CHAT:pid:channel:sound:text"
pid is the sending player.
channel is the name of the channel. alternatively, it can be a
number signifying which of the player's channels the message is
intended for.
sound is a sound code, to be interpreted by the client.
text is the text of the message.
when a player gets a ?chat message, the server receives:
b->g: "CHATTXT:channel:sender:sound:text"
b->g: "CHAT:pid:number"
channel is the name of the channel that this message is on.
sender is the name of the player who sent the message.
sound is a sound code.
text is the text of the message.
pid is the pid of a player who received the message.
number is what channel that player should see the message as coming
from.
the CHATTXT message is used so that the biller can send a chat
message to many players on one server without sending the full text
and sender name to each of them. the contents of the CHATTXT message
should be cached on the server, and the text used for any following
CHAT messages, until the next CHATTXT. for example, if the server
gets "CHATTXT:sscx:player:0:hello" and then "CHAT:22:3", player 22
should see something like "3:player> hello".
when a player sends a remote private message:
g->b: "RMT:pid:destination:sound:text"
pid is the pid of the sending player.
destination is the player the message is being sent to.
sound is a sound code.
text is the text of a message.
when a player receives a remove private message:
b->g: "RMT:pid:sender:sound:text"
pid is the pid of the player receiving the message.
sender is the name of the sending player.
sound is a sound code.
text is the text of the message.
when a player sends a squad message:
g->b: "RMTSQD:pid:destsquad:sound:text"
pid is the pid of the sender.
destsquad is the name of the squad whose players should receive the
message (no leading #).
sound is a sound code.
text is the text of the message.
when a player receives a squad message:
b->g: "RMTSQD:destsquad:sender:sound:text"
destsquad is the squad that the message is for.
sender is the name of the sending player.
sound is a sound code.
text is the text of the message.
when a player types a command that the server doesn't interpret, or that
the server knows should go to the billing server:
g->b: "CMD:pid:cmdname:args"
pid is the pid of the sending player.
cmdname is the name of the command.
args is the arguments to the command (what was typed after the
command name.
when the server wants to send a player some message (usually as the
result of a command):
b->g: "MSG:pid:sound:text"
pid is the pid of the recipient.
sound is a sound code.
text is the text of the message.
when the server wants to send some of its log output to the biller,
perhaps so logs document malicious activity can be gatherd and analyzed
for many zones at once, it can send:
g->b: "LOG:pid:logtext"
if the log message refers to the activity of a specific player, the
pid field will hold the pid of that player. if not, it should be
empty (zero-length).
logtext is the text of the log message, in whatever format the
server chooses.
if the biller wants to send a message to only staff members of a zone,
it can send:
b->g: "STAFFMSG:sender:sound:text"
sender is the optional name of whoever sent this message. if it was
generated by the billing server, it should be empty.
sound is a sound code.
text is the text of the message.
if the biller wants to send a message to the entire zone (e.g., for
scheduled downtime or other important events), it can send:
b->g: "BROADCAST:sender:sound:text"
sender is the optional name of whoever sent this message. if it was
generated by the billing server, it should be empty.
sound is a sound code.
text is the text of the message.
if the server is going down (for a shutdown or whatever), it should
close the tcp socket. if the biller is going down (for any reason), it
should close the tcp socket.
either side is allowed to send ping messages which act as a keepalive to
force tcp to detect when one or the other side of the connection crashes
or becomes unavailable. a suggested interval between pings is 180
seconds, although neither side should assume anything about the interval
that the other side is using, and should send its own keepalives if it
wants quick notification if the other side crashes or becomes
unavailable.
b->g: "PING"
g->b: "PING"
the biller can indicate that it's time for a scorereset by sending:
b->g: "SCORERESET"
# dist: public


updating every day, welcome to Beauty Diary!
Sales
Price: ～
Delivery location: choose location Ontaio Quebec Manitoba Alberta
Lancome Perfume
$278
Morphe moisturizing lipstick
$35
Marc Jacobs / Daisy Perfume
$150
Christine Dior Foundation
$80
Juicy Counture
$58
Origins Treatment Lotion
$44
Makeup Match Powder Brush
$24
ESTÉE LAUDER Night Repair
$125


I wish this website were just a joke, but it's not. As you may have heard, a
14 year-old boy was arrested, taken to the police station in handcuffs,
and suspended from school because a teacher thought his DIY digital clock was a bomb.
Source
"He’s vowed never to take an invention to school again."
Not only does this speak to racism and racial profiling still present in America today,
but the fact that they killed the innovative spirit of a young inventor is heartbreaking.


First look inside new Sainsbury's Local supermarket in Lyde Green
The store has created 24 jobs
by Robin MurrayA new supermarket has opened its doors in South Gloucestershire.
Sainsbury's opened to the public in Lyde Green this morning and will offer residents a range of grocery products and fresh foods.
The 4,024 sq ft convenience store has created 24 new jobs and will play an active role in the local community, according to a spokesperson.
It offers a wide range of fresh fruit and vegetables, dairy products, an in-store bakery and other convenience products.
It also has its own car park for customers to use.
Local residents only had a small bakery in the village to buy their food items from before the launch, however nearby Emerson's Green is home to a huge Sainsbury's superstore.
Jamie Ahearne, Sainsbury’s Lyde Green local store manager, said: "We are delighted to be opening a brand new Local store in Bristol, providing residents and shoppers with a convenient place to pick up their favourite grocery products at great value.
"The new store looks fantastic and we have a great team of colleagues who are really excited to welcome and serve customers."
Follow Discover Bristol
We have a dedicated Facebook page for all the latest on where to drink, eat, go out and events across Bristol.
From the best food and drink deals to exclusive sneak peeks at new restaurants and bars, gig reviews and weekend plans - Discover Bristol has got you covered.
You can follow the page here for all the latest news.
A spokesperson added the shop will 'support a local charity and Sainsbury’s nationwide community programmes and charity partners'.
The store, which is located in Thistle Close, BS16 7GW, will be open daily from 7am until 11pm.
For the latest news in and around Bristol, visit and bookmark Bristol Live's homepage.


History of Video Production
History of video production began with motion pictures which were based on the illusion of persistence of
vision and the
phi phenomenon. Earlier before photography was invented, optical toys were used. They were mounted on
successive phase
drawings to create the motion pictures.A home movie is a short amateur film or video typically made just to
preserve a visual record of family activities, a
vacation, or a special event, and intended for viewing at home by family and friends. Originally, home movies
were made
on photographic film in formats that usually limited the movie-maker to about three minutes per roll of costly
camera
film. The vast majority of amateur film formats lacked audio, shooting silent film.
The 1970s saw the advent of consumer camcorders that could record an hour or two of video on one relatively
inexpensive
videocassette which also had audio and did not need to be developed the way film did. This was followed by
digital video
cameras that recorded to flash memory, and most recently smartphones with video recording capability, made the
creation
of home movies easier and much more affordable to the average person.
The technological boundaries between home-movie-making and professional movie-making are becoming increasingly
blurred
as prosumer equipment often offers features previously only available on professional equipment.
How to make good video
Shooting video
When shooting please do not provide on-camera commentary or narration. This is to ensure that these videos can
be used
by similar articles in languages other than English.
The style of these videos are intended to be simple and clean. No quick zooms or handheld walk throughs. Any
movement
within the frame (panning, tilting, or zooming) should be done slowly so that the viewer is able to focus on
the detail
of the images. Try and get a reasonable balance between shots with and without movement.
If you are recording a shot with no camera movement or zoom, do not record for less than 5 seconds. If you are
zooming,
be sure to record 3 seconds before the zoom and wait at least 3 seconds after you reach the end of the shot.
The same
guidelines for zoom shots also applies to any shot that has movement (panning or tilting). Buffers will help
with the
editing of the video.
Editing video
Using editing software like iMovie or OpenShot (see List of video editing software for more options), import
the video
onto your computer to edit. Refer to instruction manuals for your specific software and camera to learn how to
import
and edit.
In the editing process of multi-shot videos, think about opening your video with a shot that helps to
establish the
location of the site (e.g.: the opening shot in the Grand Central Terminal video is of the front of the
building with
surrounding buildings).
Do not include narration, titles, transitions, special effects (with the exception of image control effects).
The reason
for this is twofold: one, to support the eventual possibility of online editing, where the inclusion of
transitions and
special effects would make re-editing difficult. Two, as stated previously, narration will render the video
incompatible
with the same article written in another language. Eventually online video editing will allow the overlay of
effects and
narration without changing the source video.
This initiative is promoting an encyclopedic brand of video that helps to establish the very basics of the
subject, and
this can be reflected in the editing (e.g., the opening shot in the Grand Central Terminal video is of the
front of the
building with surrounding buildings).
When finished, export your video. When exporting, be sure to select any options that support web streaming.
Content
Analog video
See also: Analog television and Videotape
Analog video signal from a Sony PlayStation
Video technology was first developed for mechanical television systems, which were quickly replaced by cathode
ray tube
(CRT) television systems, but several new technologies for video display devices have since been invented.
Video was
originally exclusively a live technology. Charles Ginsburg led an Ampex research team developing one of the
first
practical video tape recorders (VTR). In 1951 the first VTR captured live images from television cameras by
writing the
camera's electrical signal onto magnetic videotape.
Video recorders were sold for US$50,000 in 1956, and videotapes cost US$300 per one-hour reel.[2] However,
prices
gradually dropped over the years; in 1971, Sony began selling videocassette recorder (VCR) decks and tapes
into the
consumer market.[3]
Digital video
Main article: Digital video
See also: Digital television and Video coding format
The use of digital techniques in video created digital video. It could not initially compete with analog
video, due to
early digital uncompressed video requiring impractically high bitrates. Practical digital video was made
possible with
discrete cosine transform (DCT) coding,[4] a lossy compression process developed in the early 1970s.[5][6][7]
DCT coding
was adapted into motion-compensated DCT video compression in the late 1980s, starting with H.261,[4] the first
practical
digital video coding standard.[8]
Digital video was later capable of higher quality and, eventually, much lower cost than earlier analog
technology. After
the invention of the DVD in 1997, and later the Blu-ray Disc in 2006, sales of videotape and recording
equipment
plummeted. Advances in computer technology allows even inexpensive personal computers and smartphones to
capture, store,
edit and transmit digital video, further reducing the cost of video production, allowing program-makers and
broadcasters
to move to tapeless production. The advent of digital broadcasting and the subsequent digital television
transition is
in the process of relegating analog video to the status of a legacy technology in most parts of the world. As
of 2015,
with the increasing use of high-resolution video cameras with improved dynamic range and color gamuts, and
high-dynamic-range digital intermediate data formats with improved color depth, modern digital video
technology is
converging with digital film technology.
We do it like that
History of video production began with motion pictures which were based on the illusion of persistence of
vision and the
phi phenomenon. Earlier before photography was invented, optical toys were used. They were mounted on
successive phase
drawings to create the motion pictures.
Developer
History of video production began with motion pictures which were based on the illusion of persistence of
vision and the
phi phenomenon. Earlier before photography was invented, optical toys were used. They were mounted on
successive phase
drawings to create the motion pictures.


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Uses of Animation.RuntimeAnimation in edu.cmu.cs.stage3.alice.core.response |
|---|
| Uses of Animation.RuntimeAnimation in edu.cmu.cs.stage3.alice.core.response.visualization.array |
|---|
| Uses of Animation.RuntimeAnimation in edu.cmu.cs.stage3.alice.core.response.visualization.list |
|---|
| Uses of Animation.RuntimeAnimation in edu.cmu.cs.stage3.alice.core.response.visualization.model |
|---|
| Uses of Animation.RuntimeAnimation in edu.cmu.cs.stage3.alice.core.response.visualization.queue |
|---|
| Uses of Animation.RuntimeAnimation in edu.cmu.cs.stage3.alice.core.response.visualization.set |
|---|
| Uses of Animation.RuntimeAnimation in edu.cmu.cs.stage3.alice.core.response.visualization.stack |
|---|
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


TEST My Favorite Things
Below represents some of my favorite things...
People
- My Mom and Dad
- Carol
- Doug
- My sisters: Patsy and Margaret
- My daughters: Jessica and Julia
- Ashley
- Jeff
- Nicole
- Shayna
- Ann
- Maybe Ron
Places
- The Lake
- The Enchantments
- The Grand Tetons, Wyoming
Food
- My three favorite flavors of ice cream
- Rum Raisin
- Vanilla
- Rocky Road
- Pizza
Thanks for reading about my favorite things!


If HSNSwitch fails to run it may be that it cannot parse the HotSync record. As the HotSync record is undocumented a bit of reverse engineering must be done by using HSNDetect.
HSNDetect is a tool which collects the relevant system information and stores them in a database. The database should be mailed to me - instructions are in the README.txt in the archive.
When I have the collected information I might get a better understanding on how the HotSync record are stored on your hardware platform.
To use HSNDetect follow these steps:
I will then have a better chance of getting HSNSwitch working on your hardware platform.
v1r1 (2005-04-25) First release of HSNDetect.


Louis Tomlinson supports Vinnie Jones after X Factor: Celebrity exit
Louis Tomlinson lent his support to Vinnie Jones after the actor lost out on a place in the X Factor: Celebrity final.
Saturday’s semi-final saw a star-studded audience watch the likes of Megan McKenna and girl group V5.
Louis, a former X Factor judge himself, was spotted leaving the show with Vinnie and mucking about in front of people stood outside.
The singer was in good spirits as stopped to take pictures with fans, and posed next to the former footballer who had his arm around Louis’ shoulders.
After his exit from the live shows, Vinnie thanked Simon for helping him get through a difficult time after the death of his wife.
In a video shared on social media, the Snatch star said:‘Been a fantastic journey, absolutely enjoyed it,’ Vinnie began. ‘Simon, thank you so much for getting me through my grief, helping me a hell of a lot with it. ‘I will always be indebted to you my friend. Thank you very much.’
Advertisement Advertisement
He added: ‘All the fans out there, I’ve had a terrific time.’
Megan and V5 also had big smiles, understandable as they are both now X Factor: Celebrity finalists along with Max and Harvey and Jenny Ryan.
Love Island stars Megan Barton Hanson and Georgia Steel were also seen leaving the live shows in London.
The main man himself Simon Cowell and his girlfriend Lauren Silverman headed out in the night together following the show.
He must be feeling pretty pleased with himself having two acts – V5 and musical.ly personalities Max and Harvey – in the grand final.
Louis and Nicole are still in with a fighting chance as their respective acts, Megan and Jenny, will be singing to win on Saturday night.
Last Saturday Try Star were also sent home, made up of rugby players Thom Evans, Ben Foden and Levi Davis.
The X Factor: Celebrity final is Saturday night on ITV at 7.10pm.
Got a showbiz story?
If you've got a celebrity story, video or pictures get in touch with the Metro.co.uk entertainment team by emailing us<EMAIL_ADDRESS>calling 020 3615 2145 or by visiting our Submit Stuff page - we'd love to hear from you.
Advertisement Advertisement


Study
Barrett 2013 Rodriguez 2014 Taunton 2014 Zhang 2006 Zhang 2018
Overall (I-squared = 48.0%, p = 0.104) P=0.000
NOTE: Weights are from random effects analysis
i ' ' _- ' \ —- 1 1 1 \ 1 ' 1 \ i ' ' '
> \ \
©
WMD (95% Cl)
4.80 (0.38, 9.22)
5.00 (0.94, 9.06)
5.50 (-0.49, 11.49)
r—*— 11.00 (7.40, 14.60)
8.87 (5.87, 11.87)
7.41 (4.91, 9.92)
%
Weight
18.31 20.11 12.40 22.69 26.48
100.00
T -14.6
T 14.6


Daemo succeeds when workers and requesters collaborate to ensure fair pay and high quality work.
The requester for "{{ project_name }}" has indicated that you may have misunderstood their project.
They are asking you to revise your responses before accepting the work.
You can make changes and resubmit here.
The requester's reasoning for asking for the revision:
"{{ return_reason }}"
In cases where the requester is abusing their privileges by returning high-quality work, we will review the case and make a determination.
If you wish to contest the return, send an email to<EMAIL_ADDRESS>including the project name, the requester,
and a summary of the interaction, including the revisions that were requested.
- The Daemo Team


Introduction
The External API’s security layer is designed to support a multitude of mechanisms for authentication such as API keys, digest authentication and others. While the current implementation only supports basic authentication, further authentication mechanisms may be added in the future.
Basic Authentication
The External API is protected by basic authentication, requiring a user and a password be sent in the form of the
standard HTTP Authorization
header. (see Figure 2). In the header, the username and password are sent
encoded in Base64 format. The incoming requests are matched against an existing user whose password needs to match with
the one that is found in the Authorization request header.
NOTE: Basic authentication is not activated by default, please activate it in the security settings
(etc/security/mh_default_org.xml
) before using the External API.
Protection of authentication data
Since Base64 is by no means regarded as encryption in the sense of security, it is strongly recommended to only offer access to the External API over HTTPS rather than over HTTP in order to avoid unprotected transmission of the username and password via the Authorization header.
Validation criteria
When initiating the connection, the External API analyzes the header and extracts the username to match against an existing API user. If that user is found, the connection is authenticated, otherwise it’s rejected.


Let us first learn about some terminologies commonly used in networking.
 Each user on a network works on a workstation. If
there are no nodes there would be no network.
A computer that facilitates sharing of data, software and hardware
resources on the network is known as the server. A network can have more
than one server also.Computer Network 1.1.2 Requirements of
a network At least two computers - Server or Client workstation.
Network
Interface Cards (NIC) A connection medium, usually a wire or cable,
although wireless communication between networked computers and
peripherals Network Operating system software, such as Microsoft Windows
NT or 2000, Novell NetWare, Unix and Linux. 1.1.3 Network Terminologies
Let us first learn about some terminologies commonly used in networking.
 Each user on a network works on a workstation. If there are no
nodes there would be no network. A computer that facilitates sharing of
data, software and hardware resources s known as the server. A network
can have more than one server also. Network Interface Cards (NIC) A
connection medium, usually a wire or cable, although wireless
communication between networked computers and peripherals ware, such as
Microsoft Windows NT or 2000, Let us first learn about some
terminologies commonly used in networking.
 Each
user on a network works on a workstation. If A computer that facilitates
sharing of data, software and hardware resources s known as the server.
A network can have more than one server also. Each server has a unique
name by which it is identified by all the nodes on the network.
Servers
can be of two types:
a) Dedicated and
b) Non dedicated servers
Dedicated
Servers: These are generally used on big network installations where one
computer is reserved for the server's job. It helps all nodes access
data, software and hardware resources. Since it does not double up as a
workstation but only manages the network, it is known as a dedicated
server and such types of networks are called master- slave networks.
Non
dedicated servers: In small networks, a workstation can double up as a
server. These servers are known as non dedicated servers. The small
networks using such a server are known as Peer to Peer networks.
A network interface unit is a device that is attached to each of the workstations and the server which helps to establish communication between the server and workstations. As soon as a standalone computer becomes a workstation, it needs an interface to help establish connection with the network because without this the workstations will not be able to share network resources or communicate with each other. The NIC basically acts like an interpreter and is also known as Terminal Access Point (TAP) or Network Interface card(NIC).The NIC manufacturer assigns a unique physical address to each NIC card and this physical address is known as the MAC address.
Switching techniques are used to efficiently transmit data across the network. The two
types of switching techniques employed nowadays to provide communication between
two computers on a network are:
Circuit Switching and Packet Switching Circuit
Switching.
A technique in which a dedicated and complete physical connection is established between two nodes and through this dedicated communication channel, the nodes may communicate. The circuit guarantees the full bandwidth of the channel and remains connected for the duration of the communication session. Even if no communication is taking place in a dedicated circuit, that channel still remains unavailable to other users (idle channels). The defining example of a circuit-switched network is the early analogue telephone network. When a call is made from one telephone to another, switches within the telephone exchange create a continuous wire circuit between the two telephones, for as long as the call lasts.
A switching technique in which packets (discrete blocks of data of fixed size and of any content, type or structure) are routed between nodes over data links shared with other traffic. The term "packets" refers to the fact that the data stream from your computer is broken up into packets of about 200 bytes (on average), which are then sent out onto the network. Each packet contains a "header" with information necessary for routing the packet from source to destination. Each packet in a data stream is independent. The main advantage of packet-switching is that the packets from many different sources can share a line, allowing for very efficient use of the communication medium. With current technology, packets are generally accepted onto the network on a first-come, first-served basis. If the network becomes overloaded, packets are delayed or discarded ("dropped"). This method of data transmission became the fundamental networking technology behind the internet and most Local Area Networks
Let us learn about some data communication terminologies being used.
A communication channel is a medium that is used in the transmission of a message from one point to another. In simple terms we can say that it is a pathway over which data is transferred between remote devices. It may refer to the entire physical medium, such as a telephone line, optical fibre, coaxial cable or twisted pair wire, or, it may refer to one of the several carrier frequencies transmitted simultaneously within the line. Depending on their speed, we have three broad categories of communication channels - narrow band which is slow and used for telegraph lines and low speed terminals; voice band used for ordinary telephone communication and broadband which is fastest and is used for transmitting large volumes of data at high speeds.
In electronic communication, bandwidth refers to the range of frequencies available for transmission of data. It is expressed as the difference in Hertz(Hz) between the highest frequency and the lowest frequency. For example, a typical voice signal has a bandwidth of approximately 3KHz. Wider the bandwidth of a communication system, greater is the capacity and hence greater is the amount of data that can be transmitted over a period of time.
The data transfer rate (DTR) is the amount of data in digital form that is moved from one place to another in a given time on a network. As studied before, the greater the bandwidth of a given medium, the higher is the data transfer rate. This can also be referred to as throughput, although data transfer rate applies specifically to digital data streams. Data transfer rate is often measured in bits per second (bps), although the unit baud , which is one bit per second is also used. It is commonly used to measure how fast data is transferred from one location to another. For example, your ISP may offer an Internet connection with a maximum data transfer rate of 4Mbps.