A framework for easily creating beautiful presentations using HTML. Check out the live demo.
reveal.js comes with a broad range of features including nested slides, Markdown contents, PDF export, speaker notes and a JavaScript API. There’s also a fully featured visual editor and platform for sharing reveal.js presentations at slides.com.
Presentations are written using HTML or Markdown but there’s also an online editor for those of you who prefer a graphical interface. Give it a try at https://slides.com.
The basic setup is for authoring presentations only. The full setup gives you access to all reveal.js features and plugins such as speaker notes as well as the development tasks needed to make changes to the source.
The core of reveal.js is very easy to install. You’ll simply need to download a copy of this repository and open the index.html file directly in your browser.
Some reveal.js features, like external Markdown and speaker notes, require that presentations run from a local web server. The following instructions will set up such a server as well as all of the development tasks needed to make edits to the reveal.js source code.
Install Node.js (4.0.0 or later)
$ git clone https://github.com/hakimel/reveal.js.git
$ cd reveal.js
$ npm install
$ npm start
Open http://localhost:8000 to view your presentation
You can change the port by using npm start -- --port=8001
.
Here’s a barebones example of a fully working reveal.js presentation:

<link rel="stylesheet" href="css/reveal.css">
<link rel="stylesheet" href="css/theme/white.css">

Slide 1

Slide 2

The presentation markup hierarchy needs to be .reveal > .slides > section
where the section
represents one slide and can be repeated indefinitely. If you place multiple section
elements inside of another section
they will be shown as vertical slides. The first of the vertical slides is the “root” of the others (at the top), and will be included in the horizontal sequence. For example:

Single Horizontal Slide

Vertical Slide 1

Vertical Slide 2

It’s possible to write your slides using Markdown. To enable Markdown, add the data-markdown
attribute to your

elements and wrap the contents in a <textarea data-template>
like the example below. You’ll also need to add the plugin/markdown/marked.js
and plugin/markdown/markdown.js
scripts (in that order) to your HTML file.
This is based on data-markdown from Paul Irish modified to use marked to support GitHub Flavored Markdown. Sensitive to indentation (avoid mixing tabs and spaces) and line breaks (avoid consecutive breaks).

<textarea data-template>
## Page title
A paragraph with some text and a [link](http://hakim.se).
</textarea>

You can write your content as a separate file and have reveal.js load it at runtime. Note the separator arguments which determine how slides are delimited in the external file: the data-separator
attribute defines a regular expression for horizontal slides (defaults to ^\r?\n---\r?\n$
, a newline-bounded horizontal rule) and data-separator-vertical
defines vertical slides (disabled by default). The data-separator-notes
attribute is a regular expression for specifying the beginning of the current slide’s speaker notes (defaults to notes?:
, so it will match both “note:” and “notes:”). The data-charset
attribute is optional and specifies which charset to use when loading the external file.
When used locally, this feature requires that reveal.js runs from a local web server. The following example customises all available options:

Special syntax (through HTML comments) is available for adding attributes to Markdown elements. This is useful for fragments, amongst other things.

Special syntax (through HTML comments) is available for adding attributes to the slide

elements generated by your Markdown.

We use marked to parse Markdown. To customise marked’s rendering, you can pass in options when configuring Reveal:
Reveal.initialize({
// Options which are passed into marked
// See https://marked.js.org/#/USING_ADVANCED.md#options
markdown: {
smartypants: true
}
});
At the end of your page you need to initialize reveal by running the following code. Note that all configuration values are optional and will default to the values specified below.
Reveal.initialize({
// Display presentation control arrows
controls: true,
// Help the user learn the controls by providing hints, for example by
// bouncing the down arrow when they first encounter a vertical slide
controlsTutorial: true,
// Determines where controls appear, "edges" or "bottom-right"
controlsLayout: 'bottom-right',
// Visibility rule for backwards navigation arrows; "faded", "hidden"
// or "visible"
controlsBackArrows: 'faded',
// Display a presentation progress bar
progress: true,
// Display the page number of the current slide
slideNumber: false,
// Add the current slide number to the URL hash so that reloading the
// page/copying the URL will return you to the same slide
hash: false,
// Push each slide change to the browser history. Implies `hash: true`
history: false,
// Enable keyboard shortcuts for navigation
keyboard: true,
// Enable the slide overview mode
overview: true,
// Vertical centering of slides
center: true,
// Enables touch navigation on devices with touch input
touch: true,
// Loop the presentation
loop: false,
// Change the presentation direction to be RTL
rtl: false,
// See https://github.com/hakimel/reveal.js/#navigation-mode
navigationMode: 'default',
// Randomizes the order of slides each time the presentation loads
shuffle: false,
// Turns fragments on and off globally
fragments: true,
// Flags whether to include the current fragment in the URL,
// so that reloading brings you to the same fragment position
fragmentInURL: false,
// Flags if the presentation is running in an embedded mode,
// i.e. contained within a limited portion of the screen
embedded: false,
// Flags if we should show a help overlay when the questionmark
// key is pressed
help: true,
// Flags if speaker notes should be visible to all viewers
showNotes: false,
// Global override for autoplaying embedded media (video/audio/iframe)
// - null: Media will only autoplay if data-autoplay is present
// - true: All media will autoplay, regardless of individual setting
// - false: No media will autoplay, regardless of individual setting
autoPlayMedia: null,
// Global override for preloading lazy-loaded iframes
// - null: Iframes with data-src AND data-preload will be loaded when within
// the viewDistance, iframes with only data-src will be loaded when visible
// - true: All iframes with data-src will be loaded when within the viewDistance
// - false: All iframes with data-src will be loaded only when visible
preloadIframes: null,
// Number of milliseconds between automatically proceeding to the
// next slide, disabled when set to 0, this value can be overwritten
// by using a data-autoslide attribute on your slides
autoSlide: 0,
// Stop auto-sliding after user input
autoSlideStoppable: true,
// Use this method for navigation when auto-sliding
autoSlideMethod: Reveal.navigateNext,
// Specify the average time in seconds that you think you will spend
// presenting each slide. This is used to show a pacing timer in the
// speaker view
defaultTiming: 120,
// Enable slide navigation via mouse wheel
mouseWheel: false,
// Hide cursor if inactive
hideInactiveCursor: true,
// Time before the cursor is hidden (in ms)
hideCursorTime: 5000,
// Hides the address bar on mobile devices
hideAddressBar: true,
// Opens links in an iframe preview overlay
// Add `data-preview-link` and `data-preview-link="false"` to customise each link
// individually
previewLinks: false,
// Transition style
transition: 'slide', // none/fade/slide/convex/concave/zoom
// Transition speed
transitionSpeed: 'default', // default/fast/slow
// Transition style for full page slide backgrounds
backgroundTransition: 'fade', // none/fade/slide/convex/concave/zoom
// Number of slides away from the current that are visible
viewDistance: 3,
// Parallax background image
parallaxBackgroundImage: '', // e.g. "'https://s3.amazonaws.com/hakim-static/reveal-js/reveal-parallax-1.jpg'"
// Parallax background size
parallaxBackgroundSize: '', // CSS syntax, e.g. "2100px 900px"
// Number of pixels to move the parallax background per slide
// - Calculated automatically unless specified
// - Set to 0 to disable movement along an axis
parallaxBackgroundHorizontal: null,
parallaxBackgroundVertical: null,
// The display mode that will be used to show slides
display: 'block'
});
The configuration can be updated after initialization using the configure
method:
// Turn autoSlide off
Reveal.configure({ autoSlide: 0 });
// Start auto-sliding every 5s
Reveal.configure({ autoSlide: 5000 });
All presentations have a normal size, that is, the resolution at which they are authored. The framework will automatically scale presentations uniformly based on this size to ensure that everything fits on any given display or viewport.
See below for a list of configuration options related to sizing, including default values:
Reveal.initialize({
// ...
// The "normal" size of the presentation, aspect ratio will be preserved
// when the presentation is scaled to fit different resolutions. Can be
// specified using percentage units.
width: 960,
height: 700,
// Factor of the display size that should remain empty around the content
margin: 0.1,
// Bounds for smallest/largest possible scale to apply to content
minScale: 0.2,
maxScale: 1.5
});
If you wish to disable this behavior and do your own scaling (e.g. using media queries), try these settings:
Reveal.initialize({
// ...
width: "100%",
height: "100%",
margin: 0,
minScale: 1,
maxScale: 1
});
Reveal.js doesn’t rely on any third party scripts to work but a few optional libraries are included by default. These libraries are loaded as dependencies in the order they appear, for example:
Reveal.initialize({
dependencies: [
// Interpret Markdown in
 elements
{ src: 'plugin/markdown/marked.js', condition: function() { return !!document.querySelector( '[data-markdown]' ); } },
{ src: 'plugin/markdown/markdown.js', condition: function() { return !!document.querySelector( '[data-markdown]' ); } },
// Syntax highlight for  elements
{ src: 'plugin/highlight/highlight.js', async: true },
// Zoom in and out with Alt+click
{ src: 'plugin/zoom-js/zoom.js', async: true },
// Speaker notes
{ src: 'plugin/notes/notes.js', async: true },
// MathJax
{ src: 'plugin/math/math.js', async: true }
]
});
You can add your own extensions using the same syntax. The following properties are available for each dependency object:
A ready
event is fired when reveal.js has loaded all non-async dependencies and is ready to start navigating. To check if reveal.js is already ‘ready’ you can call Reveal.isReady()
.
Reveal.addEventListener( 'ready', function( event ) {
// event.currentSlide, event.indexh, event.indexv
} );
Note that we also add a .ready
class to the .reveal
element so that you can hook into this with CSS.
Presentations can be configured to progress through slides automatically, without any user input. To enable this you will need to tell the framework how many milliseconds it should wait between slides:
// Slide every five seconds
Reveal.configure({
autoSlide: 5000
});
When this is turned on a control element will appear that enables users to pause and resume auto-sliding. Alternatively, sliding can be paused or resumed by pressing »A« on the keyboard. Sliding is paused automatically as soon as the user starts navigating. You can disable these controls by specifying autoSlideStoppable: false
in your reveal.js config.
You can also override the slide duration for individual slides and fragments by using the data-autoslide
attribute:

After 2 seconds the first fragment will be shown.

After 10 seconds the next fragment will be shown.

Now, the fragment is displayed for 2 seconds before the next slide is shown.

To override the method used for navigation when auto-sliding, you can specify the autoSlideMethod
setting. To only navigate along the top layer and ignore vertical slides, set this to Reveal.navigateRight
.
Whenever the auto-slide mode is resumed or paused the autoslideresumed
and autoslidepaused
events are fired.
If you’re unhappy with any of the default keyboard bindings you can override them using the keyboard
config option:
Reveal.configure({
keyboard: {
13: 'next', // go to the next slide when the ENTER key is pressed
27: function() {}, // do something custom when ESC is pressed
32: null // don't do anything when SPACE is pressed (i.e. disable a reveal.js default binding)
}
});
Slides can be nested within other slides to create vertical stacks (see Markup). When presenting, you use the left/right arrows to step through the main (horizontal) slides. When you arrive at a vertical stack you can optionally press the up/down arrows to view the vertical slides or skip past them by pressing the right arrow. Here’s an example showing a bird’s-eye view of what this looks like in action:
You can finetune the reveal.js navigation behavior by using the navigationMode
config option. Note that these options are only useful for presnetations that use a mix of horizontal and vertical slides. The following navigation modes are available:
| Value | Description |
|---|---|
| default | Left/right arrow keys step between horizontal slides. Up/down arrow keys step between vertical slides. Space key steps through all slides (both horizontal and vertical). |
| linear | Removes the up/down arrows. Left/right arrows step through all slides (both horizontal and vertical). |
| grid | When this is enabled, stepping left/right from a vertical stack to an adjacent vertical stack will land you at the same vertical index. Consider a deck with six slides ordered in two vertical stacks: 1.1 2.1 1.2 2.2 1.3 2.3 If you’re on slide 1.3 and navigate right, you will normally move from 1.3 -> 2.1. With navigationMode set to “grid” the same navigation takes you from 1.3 -> 2.3. |
You can swipe to navigate through a presentation on any touch-enabled device. Horizontal swipes change between horizontal slides, vertical swipes change between vertical slides. If you wish to disable this you can set the touch
config option to false when initializing reveal.js.
If there’s some part of your content that needs to remain accessible to touch events you’ll need to highlight this by adding a data-prevent-swipe
attribute to the element. One common example where this is useful is elements that need to be scrolled.
When working on presentation with a lot of media or iframe content it’s important to load lazily. Lazy loading means that reveal.js will only load content for the few slides nearest to the current slide. The number of slides that are preloaded is determined by the viewDistance
configuration option.
To enable lazy loading all you need to do is change your src
attributes to data-src
as shown below.  Iframes are also unloaded as soon as the slide is hidden.
When we lazy load a video or audio element, reveal.js won’t start playing that content until the slide becomes visible. However there is no way to control this for an iframe since that could contain any kind of content. That means if we loaded an iframe before the slide is visible on screen it could begin playing media and sound in the background.
You can override this behavior with the data-preload
attribute. The iframe below will be loaded
according to the viewDistance
.

You can also change the default globally with the preloadIframes
configuration option. If set to
true
ALL iframes with a data-src
attribute will be preloaded when within the viewDistance
regardless of individual data-preload
attributes. If set to false
, all iframes will only be
loaded when they become visible.
The Reveal
object exposes a JavaScript API for controlling navigation and reading state:
// Navigation
Reveal.slide( indexh, indexv, indexf );
Reveal.left();
Reveal.right();
Reveal.up();
Reveal.down();
Reveal.prev();
Reveal.next();
Reveal.prevFragment();
Reveal.nextFragment();
// Randomize the order of slides
Reveal.shuffle();
// Toggle presentation states, optionally pass true/false to force on/off
Reveal.toggleOverview();
Reveal.togglePause();
Reveal.toggleAutoSlide();
// Shows a help overlay with keyboard shortcuts, optionally pass true/false
// to force on/off
Reveal.toggleHelp();
// Change a config value at runtime
Reveal.configure({ controls: true });
// Returns the present configuration options
Reveal.getConfig();
// Fetch the current scale of the presentation
Reveal.getScale();
// Retrieves the previous and current slide elements
Reveal.getPreviousSlide();
Reveal.getCurrentSlide();
Reveal.getIndices(); // { h: 0, v: 0, f: 0 }
Reveal.getSlidePastCount();
Reveal.getProgress(); // (0 == first slide, 1 == last slide)
Reveal.getSlides(); // Array of all slides
Reveal.getTotalSlides(); // Total number of slides
// Returns the speaker notes for the current slide
Reveal.getSlideNotes();
// State checks
Reveal.isFirstSlide();
Reveal.isLastSlide();
Reveal.isOverview();
Reveal.isPaused();
Reveal.isAutoSliding();
// Returns the top-level DOM element
getRevealElement(); //
...

Custom key bindings can be added and removed using the following Javascript API. Custom key bindings will override the default keyboard bindings, but will in turn be overridden by the user defined bindings in the keyboard
config option.
Reveal.addKeyBinding( binding, callback );
Reveal.removeKeyBinding( keyCode );
For example
// The binding parameter provides the following properties
// keyCode: the keycode for binding to the callback
// key: the key label to show in the help overlay
// description: the description of the action to show in the help overlay
Reveal.addKeyBinding( { keyCode: 84, key: 'T', description: 'Start timer' }, function() {
// start timer
} )
// The binding parameter can also be a direct keycode without providing the help description
Reveal.addKeyBinding( 82, function() {
// reset timer
} )
This allows plugins to add key bindings directly to Reveal so they can
A slidechanged
event is fired each time the slide is changed (regardless of state). The event object holds the index values of the current slide as well as a reference to the previous and current slide HTML nodes.
Some libraries, like MathJax (see #226), get confused by the transforms and display states of slides. Often times, this can be fixed by calling their update or render function from this callback.
Reveal.addEventListener( 'slidechanged', function( event ) {
// event.previousSlide, event.currentSlide, event.indexh, event.indexv
} );
The presentation’s current state can be fetched by using the getState
method. A state object contains all of the information required to put the presentation back as it was when getState
was first called. Sort of like a snapshot. It’s a simple object that can easily be stringified and persisted or sent over the wire.
Reveal.slide( 1 );
// we're on slide 1
var state = Reveal.getState();
Reveal.slide( 3 );
// we're on slide 3
Reveal.setState( state );
// we're back on slide 1
If you set data-state="somestate"
on a slide

, “somestate” will be applied as a class on the document element when that slide is opened. This allows you to apply broad style changes to the page based on the active slide.
Furthermore you can also listen to these changes in state via JavaScript:
Reveal.addEventListener( 'somestate', function() {
// TODO: Sprinkle magic
}, false );
Slides are contained within a limited portion of the screen by default to allow them to fit any display and scale uniformly. You can apply full page backgrounds outside of the slide area by adding a data-background
attribute to your

elements. Four different types of backgrounds are supported: color, image, video and iframe.
All CSS color formats are supported, including hex values, keywords, rgba()
or hsl()
.

Color

By default, background images are resized to cover the full page. Available options:
| Attribute | Default | Description |
|---|---|---|
| data-background-image | URL of the image to show. GIFs restart when the slide opens. | |
| data-background-size | cover | See background-size on MDN. |
| data-background-position | center | See background-position on MDN. |
| data-background-repeat | no-repeat | See background-repeat on MDN. |
| data-background-opacity | 1 | Opacity of the background image on a 0-1 scale. 0 is transparent and 1 is fully opaque. |

Image

This background image will be sized to 100px and repeated

Automatically plays a full size video behind the slide.
| Attribute | Default | Description |
|---|---|---|
| data-background-video | A single video source, or a comma separated list of video sources. | |
| data-background-video-loop | false | Flags if the video should play repeatedly. |
| data-background-video-muted | false | Flags if the audio should be muted. |
| data-background-size | cover | Use cover for full screen and some cropping or contain for letterboxing. |
| data-background-opacity | 1 | Opacity of the background video on a 0-1 scale. 0 is transparent and 1 is fully opaque. |

Video

Embeds a web page as a slide background that covers 100% of the reveal.js width and height. The iframe is in the background layer, behind your slides, and as such it’s not possible to interact with it by default. To make your background interactive, you can add the data-background-interactive
attribute.

Iframe

Backgrounds transition using a fade animation by default. This can be changed to a linear sliding transition by passing backgroundTransition: 'slide'
to the Reveal.initialize()
call. Alternatively you can set data-background-transition
on any section with a background to override that specific transition.
If you want to use a parallax scrolling background, set the first two properties below when initializing reveal.js (the other two are optional).
Reveal.initialize({
// Parallax background image
parallaxBackgroundImage: '', // e.g. "https://s3.amazonaws.com/hakim-static/reveal-js/reveal-parallax-1.jpg"
// Parallax background size
parallaxBackgroundSize: '', // CSS syntax, e.g. "2100px 900px" - currently only pixels are supported (don't use % or auto)
// Number of pixels to move the parallax background per slide
// - Calculated automatically unless specified
// - Set to 0 to disable movement along an axis
parallaxBackgroundHorizontal: 200,
parallaxBackgroundVertical: 50
});
Make sure that the background size is much bigger than screen size to allow for some scrolling. View example.
The global presentation transition is set using the transition
config value. You can override the global transition for a specific slide by using the data-transition
attribute:

This slide will override the presentation transition and zoom!

Choose from three transition speeds: default, fast or slow!

You can also use different in and out transitions for the same slide:

The train goes on …

and on …

and stops.

(Passengers entering and leaving)

And it starts again.

You can choose from none
, fade
, slide
, convex
, concave
and zoom
.
It’s easy to link between slides. The first example below targets the index of another slide whereas the second targets a slide with an ID attribute (

):
Link
Link
You can also add relative navigation links, similar to the built in reveal.js controls, by appending one of the following classes on any element. Note that each element is automatically given an enabled
class when it’s a valid navigation route based on the current slide.

Fragments are used to highlight individual elements on a slide. Every element with the class fragment
will be stepped through before moving on to the next slide. Here’s an example: http://revealjs.com/#/fragments
The default fragment style is to start out invisible and fade in. This style can be changed by appending a different class to the fragment:

grow

shrink

fade-out

fade-up (also down, left and right!)

fades in, then out when we move to the next step

fades in, then obfuscate when we move to the next step

blue only once

highlight-red

highlight-green

highlight-blue

Multiple fragments can be applied to the same element sequentially by wrapping it, this will fade in the text on the first step and fade it back out on the second.

I'll fade in, then out

The display order of fragments can be controlled using the data-fragment-index
attribute.

Appears last

Appears first

Appears second

When a slide fragment is either shown or hidden reveal.js will dispatch an event.
Some libraries, like MathJax (see #505), get confused by the initially hidden fragment elements. Often times this can be fixed by calling their update or render function from this callback.
Reveal.addEventListener( 'fragmentshown', function( event ) {
// event.fragment = the fragment DOM element
} );
Reveal.addEventListener( 'fragmenthidden', function( event ) {
// event.fragment = the fragment DOM element
} );
By default, Reveal is configured with highlight.js for code syntax highlighting. To enable syntax highlighting, you’ll have to load the highlight plugin (plugin/highlight/highlight.js) and a highlight.js CSS theme (Reveal comes packaged with the Monokai themes: lib/css/monokai.css).
Reveal.initialize({
// More info https://github.com/hakimel/reveal.js#dependencies
dependencies: [
{ src: 'plugin/highlight/highlight.js', async: true },
]
});
Below is an example with clojure code that will be syntax highlighted. When the data-trim
attribute is present, surrounding whitespace is automatically removed. HTML will be escaped by default. To avoid this, for example if you are using
to call out a line of code, add the data-noescape
attribute to the
element.

(def lazy-fib
(concat
[0 1]
((fn rfib [a b]
(lazy-cons (+ a b) (rfib b (+ a b)))) 0 1)))

To enable line numbers, add data-line-numbers
to your
tags. If you want to highlight specific lines you can provide a comma separated list of line numbers using the same attribute. For example, in the following example lines 4 and 8-11 are highlighted:

import React, { useState } from 'react';
function Example() {
const [count, setCount] = useState(0);
return (

You clicked {count} times

<button onClick={() => setCount(count + 1)}>
Click me
</button>

);
}

If you would like to display the page number of the current slide you can do so using the slideNumber
and showSlideNumber
configuration values.
// Shows the slide number using default formatting
Reveal.configure({ slideNumber: true });
// Slide number formatting can be configured using these variables:
// "h.v": horizontal . vertical slide number (default)
// "h/v": horizontal / vertical slide number
// "c": flattened slide number
// "c/t": flattened slide number / total slides
Reveal.configure({ slideNumber: 'c/t' });
// You can provide a function to fully customize the number:
Reveal.configure({ slideNumber: function() {
// Ignore numbering of vertical slides
return [ Reveal.getIndices().h ];
}});
// Control which views the slide number displays on using the "showSlideNumber" value:
// "all": show on all views (default)
// "speaker": only show slide numbers on speaker notes view
// "print": only show slide numbers when printing to PDF
Reveal.configure({ showSlideNumber: 'speaker' });
Press »ESC« or »O« keys to toggle the overview mode on and off. While you’re in this mode, you can still navigate between slides, as if you were at 1,000 feet above your presentation. The overview mode comes with a few API hooks:
Reveal.addEventListener( 'overviewshown', function( event ) { /* ... */ } );
Reveal.addEventListener( 'overviewhidden', function( event ) { /* ... */ } );
// Toggle the overview mode programmatically
Reveal.toggleOverview();
Just press »F« on your keyboard to show your presentation in fullscreen mode. Press the »ESC« key to exit fullscreen mode.
Add data-autoplay
to your media element if you want it to automatically start playing when the slide is shown:
<video data-autoplay src="http://clips.vorwaerts-gmbh.de/big_buck_bunny.mp4"></video>
If you want to enable or disable autoplay globally, for all embedded media, you can use the autoPlayMedia
configuration option. If you set this to true
ALL media will autoplay regardless of individual data-autoplay
attributes. If you initialize with autoPlayMedia: false
NO media will autoplay.
Note that embedded HTML5 <video>
/<audio>
and YouTube/Vimeo iframes are automatically paused when you navigate away from a slide. This can be disabled by decorating your element with a data-ignore
attribute.
reveal.js automatically pushes two post messages to embedded iframes. slide:start
when the slide containing the iframe is made visible and slide:stop
when it is hidden.
Sometimes it’s desirable to have an element, like an image or video, stretch to consume as much space as possible within a given slide. This can be done by adding the .stretch
class to an element as seen below:

This video will use up the remaining space on the slide

<video class="stretch" src="http://clips.vorwaerts-gmbh.de/big_buck_bunny.mp4"></video>

Limitations:
When reveal.js changes the scale of the slides it fires a resize event. You can subscribe to the event to resize your elements accordingly.
Reveal.addEventListener( 'resize', function( event ) {
// event.scale, event.oldScale, event.size
} );
The framework has a built-in postMessage API that can be used when communicating with a presentation inside of another window. Here’s an example showing how you’d make a reveal.js instance in the given window proceed to slide 2:
<window>.postMessage( JSON.stringify({ method: 'slide', args: [ 2 ] }), '*' );
When reveal.js runs inside of an iframe it can optionally bubble all of its events to the parent. Bubbled events are stringified JSON with three fields: namespace, eventName and state. Here’s how you subscribe to them from the parent window:
window.addEventListener( 'message', function( event ) {
var data = JSON.parse( event.data );
if( data.namespace === 'reveal' && data.eventName ==='slidechanged' ) {
// Slide changed, see data.state for slide number
}
} );
This cross-window messaging can be toggled on or off using configuration flags.
Reveal.initialize({
// ...
// Exposes the reveal.js API through window.postMessage
postMessage: true,
// Dispatches all reveal.js events to the parent window through postMessage
postMessageEvents: false
});
Presentations can be exported to PDF via a special print stylesheet. This feature requires that you use Google Chrome or Chromium and to be serving the presentation from a web server. Here’s an example of an exported presentation that’s been uploaded to SlideShare: http://www.slideshare.net/hakimel/revealjs-300.
Fragments are printed on separate slides by default. Meaning if you have a slide with three fragment steps, it will generate three separate slides where the fragments appear incrementally.
If you prefer printing all fragments in their visible states on the same slide you can set the pdfSeparateFragments
config option to false.
Export dimensions are inferred from the configured presentation size. Slides that are too tall to fit within a single page will expand onto multiple pages. You can limit how many pages a slide may expand onto using the pdfMaxPagesPerSlide
config option, for example Reveal.configure({ pdfMaxPagesPerSlide: 1 })
ensures that no slide ever grows to more than one printed page.
To enable the PDF print capability in your presentation, the special print stylesheet at /css/print/pdf.css must be loaded. The default index.html file handles this for you when print-pdf
is included in the query string. If you’re using a different HTML template, you can add this to your HEAD:

print-pdf
included in the query string i.e. http://localhost:8000/?print-pdf. You can test this with revealjs.com?print-pdf.
showNotes=true
to the query string: http://localhost:8000/?print-pdf&showNotes=trueAlternatively you can use the decktape project.
The framework comes with a few different themes included:
Each theme is available as a separate stylesheet. To change theme you will need to replace black below with your desired theme name in index.html:
<link rel="stylesheet" href="css/theme/black.css" id="theme">
If you want to add a theme of your own see the instructions here: /css/theme/README.md.
reveal.js comes with a speaker notes plugin which can be used to present per-slide notes in a separate browser window. The notes window also gives you a preview of the next upcoming slide so it may be helpful even if you haven’t written any notes. Press the »S« key on your keyboard to open the notes window.
A speaker timer starts as soon as the speaker view is opened. You can reset it to 00:00:00 at any time by simply clicking/tapping on it.
Notes are defined by appending an
element to a slide as seen below. You can add the data-markdown
attribute to the aside element if you prefer writing notes using Markdown.
Alternatively you can add your notes in a data-notes
attribute on the slide. Like

.
When used locally, this feature requires that reveal.js runs from a local web server.

Some Slide

Oh hey, these are some notes. They'll be hidden in your presentation, but you can see them if you open the speaker notes window (hit »S« on your keyboard).

If you’re using the external Markdown plugin, you can add notes with the help of a special delimiter:

# Title
## Sub-title
Here is some content...
Note:
This will only display in the notes window.
Notes are only visible to the speaker inside of the speaker view. If you wish to share your notes with others you can initialize reveal.js with the showNotes
configuration value set to true
. Notes will appear along the bottom of the presentations.
When showNotes
is enabled notes are also included when you export to PDF. By default, notes are printed in a box on top of the slide. If you’d rather print them on a separate page, after the slide, set showNotes: "separate-page"
.
The speaker notes window will also show:
The pacing timer can be enabled by configuring by the defaultTiming
parameter in the Reveal
configuration block, which specifies the number of seconds per slide. 120 can be a reasonable rule of thumb. Timings can also be given per slide

by setting the data-timing
attribute. Both values are in numbers of seconds.
In some cases it can be desirable to run notes on a separate device from the one you’re presenting on. The Node.js-based notes plugin lets you do this using the same note definitions as its client side counterpart. Include the required scripts by adding the following dependencies:
Reveal.initialize({
// ...
dependencies: [
{ src: 'socket.io/socket.io.js', async: true },
{ src: 'plugin/notes-server/client.js', async: true }
]
});
Then:
npm install
node plugin/notes-server
Plugins should register themselves with reveal.js by calling Reveal.registerPlugin( 'myPluginID', MyPlugin )
. Registered plugin instances can optionally expose an “init” function that reveal.js will call to initialize them.
When reveal.js is booted up via Reveal.initialize()
, it will go through all registered plugins and invoke their “init” methods. If the “init” method returns a Promise, reveal.js will wait for that promise to be fullfilled before finshing the startup sequence and firing the ready event. Here’s an example of a plugin that does some asynchronous work before reveal.js can proceed:
let MyPlugin = {
init: () => new Promise( resolve => setTimeout( resolve, 3000 ) )
};
Reveal.registerPlugin( 'myPlugin', MyPlugin );
Reveal.addEventListener( 'ready', () => console.log( 'Three seconds later...' ) );
Reveal.initialize();
If the init method does not return a Promise, the plugin is considered ready right away and will not hold up the reveal.js startup sequence.
If you want to check if a specific plugin is registered you can use the Reveal.hasPlugin
method and pass in a plugin ID, for example: Reveal.hasPlugin( 'myPlugin' )
. If you want to retrieve a plugin instance you can use Reveal.getPlugin( 'myPlugin' )
.
The multiplex plugin allows your audience to view the slides of the presentation you are controlling on their own phone, tablet or laptop. As the master presentation navigates the slides, all client presentations will update in real time. See a demo at https://reveal-js-multiplex-ccjbegmaii.now.sh/.
The multiplex plugin needs the following 3 things to operate:
Served from a static file server accessible (preferably) only to the presenter. This need only be on your (the presenter’s) computer. (It’s safer to run the master presentation from your own computer, so if the venue’s Internet goes down it doesn’t stop the show.) An example would be to execute the following commands in the directory of your master presentation:
npm install node-static
static
If you want to use the speaker notes plugin with your master presentation then make sure you have the speaker notes plugin configured correctly along with the configuration shown below, then execute node plugin/notes-server
in the directory of your master presentation. The configuration below will cause it to connect to the socket.io server as a master, as well as launch your speaker-notes/static-file server.
You can then access your master presentation at http://localhost:1947
Example configuration:
Reveal.initialize({
// other options...
multiplex: {
// Example values. To generate your own, see the socket.io server instructions.
secret: '13652805320794272084', // Obtained from the socket.io server. Gives this (the master) control of the presentation
id: '1ea875674b17ca76', // Obtained from socket.io server
url: 'https://reveal-js-multiplex-ccjbegmaii.now.sh' // Location of socket.io server
},
// Don't forget to add the dependencies
dependencies: [
{ src: '//cdnjs.cloudflare.com/ajax/libs/socket.io/2.2.0/socket.io.js', async: true },
{ src: 'plugin/multiplex/master.js', async: true },
// and if you want speaker notes
{ src: 'plugin/notes-server/client.js', async: true }
// other dependencies...
]
});
Served from a publicly accessible static file server. Examples include: GitHub Pages, Amazon S3, Dreamhost, Akamai, etc. The more reliable, the better. Your audience can then access the client presentation via http://example.com/path/to/presentation/client/index.html
, with the configuration below causing them to connect to the socket.io server as clients.
Example configuration:
Reveal.initialize({
// other options...
multiplex: {
// Example values. To generate your own, see the socket.io server instructions.
secret: null, // null so the clients do not have control of the master presentation
id: '1ea875674b17ca76', // id, obtained from socket.io server
url: 'https://reveal-js-multiplex-ccjbegmaii.now.sh' // Location of socket.io server
},
// Don't forget to add the dependencies
dependencies: [
{ src: '//cdnjs.cloudflare.com/ajax/libs/socket.io/2.2.0/socket.io.js', async: true },
{ src: 'plugin/multiplex/client.js', async: true }
// other dependencies...
]
});
Server that receives the slideChanged
events from the master presentation and broadcasts them out to the connected client presentations. This needs to be publicly accessible. You can run your own socket.io server with the commands:
npm install
node plugin/multiplex
Or you can use the socket.io server at https://reveal-js-multiplex-ccjbegmaii.now.sh/.
You’ll need to generate a unique secret and token pair for your master and client presentations. To do so, visit http://example.com/token
, where http://example.com
is the location of your socket.io server. Or if you’re going to use the socket.io server at https://reveal-js-multiplex-ccjbegmaii.now.sh/, visit https://reveal-js-multiplex-ccjbegmaii.now.sh/token.
You are very welcome to point your presentations at the Socket.io server running at https://reveal-js-multiplex-ccjbegmaii.now.sh/, but availability and stability are not guaranteed.
For anything mission critical I recommend you run your own server. The easiest way to do this is by installing now. With that installed, deploying your own Multiplex server is as easy running the following command from the reveal.js folder: now plugin/multiplex
.
The socket.io server can play the role of static file server for your client presentation, as in the example at https://reveal-js-multiplex-ccjbegmaii.now.sh/. (Open https://reveal-js-multiplex-ccjbegmaii.now.sh/ in two browsers. Navigate through the slides on one, and the other will update to match.)
Example configuration:
Reveal.initialize({
// other options...
multiplex: {
// Example values. To generate your own, see the socket.io server instructions.
secret: null, // null so the clients do not have control of the master presentation
id: '1ea875674b17ca76', // id, obtained from socket.io server
url: 'example.com:80' // Location of your socket.io server
},
// Don't forget to add the dependencies
dependencies: [
{ src: '//cdnjs.cloudflare.com/ajax/libs/socket.io/2.2.0/socket.io.js', async: true },
{ src: 'plugin/multiplex/client.js', async: true }
// other dependencies...
]
It can also play the role of static file server for your master presentation and client presentations at the same time (as long as you don’t want to use speaker notes). (Open https://reveal-js-multiplex-ccjbegmaii.now.sh/ in two browsers. Navigate through the slides on one, and the other will update to match. Navigate through the slides on the second, and the first will update to match.) This is probably not desirable, because you don’t want your audience to mess with your slides while you’re presenting. ;)
Example configuration:
Reveal.initialize({
// other options...
multiplex: {
// Example values. To generate your own, see the socket.io server instructions.
secret: '13652805320794272084', // Obtained from the socket.io server. Gives this (the master) control of the presentation
id: '1ea875674b17ca76', // Obtained from socket.io server
url: 'example.com:80' // Location of your socket.io server
},
// Don't forget to add the dependencies
dependencies: [
{ src: '//cdnjs.cloudflare.com/ajax/libs/socket.io/2.2.0/socket.io.js', async: true },
{ src: 'plugin/multiplex/master.js', async: true },
{ src: 'plugin/multiplex/client.js', async: true }
// other dependencies...
]
});
If you want to display math equations in your presentation you can easily do so by including this plugin. The plugin is a very thin wrapper around the MathJax library. To use it you’ll need to include it as a reveal.js dependency, find our more about dependencies here.
The plugin defaults to using LaTeX but that can be adjusted through the math
configuration object. Note that MathJax is loaded from a remote server. If you want to use it offline you’ll need to download a copy of the library and adjust the mathjax
configuration value.
Below is an example of how the plugin can be configured. If you don’t intend to change these values you do not need to include the math
config object at all.
Reveal.initialize({
// other options ...
math: {
mathjax: 'https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js',
config: 'TeX-AMS_HTML-full' // See http://docs.mathjax.org/en/latest/config-files.html
// pass other options into `MathJax.Hub.Config()`
TeX: { Macros: macros }
},
dependencies: [
{ src: 'plugin/math/math.js', async: true }
]
});
Read MathJax’s documentation if you need HTTPS delivery or serving of specific versions for stability.
If you want to include math inside of a presentation written in Markdown you need to wrap the formula in backticks. This prevents syntax conflicts between LaTeX and Markdown. For example:
`$$ J(\theta_0,\theta_1) = \sum_{i=0} $$`
MIT licensed
Copyright (C) 2019 Hakim El Hattab, http://hakim.se


You can also write content in HTML, and freely mix Markdown and HTML pages.
The only constraint is that pages have extensions of ".md" for Markdown pages and ".htm" or ".html" for HTML pages.
And yes, this page is in HTML, whilst all the other pages are in Markdown.
I find Markdown quicker to write and edit - but it's up to you!
Warning: pureHelp does not check or clean content - this is your responsibility as the author. It's your system and you can embed javascripts plus anything else, good or bad that HTML supports.


bool sqlite_exec ( resource $dbhandle , string $query [, string &$error_msg ] )
bool sqlite_exec ( string $query , resource $dbhandle )
Object oriented style (method): bool SQLiteDatabase::queryExec ( string $query [, string &$error_msg ] )
Executes an SQL statement given by the query against a given database handle (specified by the dbhandle parameter). Warning SQLite will execute multiple queries separated by semicolons, so you can use it to execute a batch of SQL that you have loaded from a file or have embedded in a script.
This function will return a boolean result; TRUE for success or FALSE for failure. If you need to run a query that returns rows, see sqlite_query(). The column names returned by SQLITE_ASSOC and SQLITE_BOTH will be case-folded according to the value of the sqlite.assoc_case configuration option.


We got systems!
- mesh intuitive users
- brand mission-critical web services
- seize granular interfaces
- implement integrated partnerships
- transform strategic applications
- orchestrate leading-edge e-tailers
- benchmark sexy ROI
- redefine sexy models
- optimize robust experiences


David Tremont, Model maker, Weta Workshop, New Zealand
I have watched Thunderbirds so many times that when I can see the characters in my mind as I read the story I know that I am enjoying the book. A great read with plenty of action and excitement. All the craft get to stretch their legs on the many rescues, definitely “action alert.”
...............................................................
All the Tracys are dedicated men of action, and Scott Tracy is no exception! The eldest of Jeff Tracy's sons, Scott pilots the rocket-reconnaissance aircraft, Thunderbird 1. First to arrive at any disaster scene, he evaluates the situation and coordinates the team's rescue strategy on site. Due to the importance of Thunderbird 1 to International Rescue's operation, Scott is present for nearly every rescue mission. Nonetheless, even Scott has his limitations, and in Action Alert, he stretches himself to those very limits. Can he do so without consequences to himself and International Rescue?


CRP virus viral APP levels protein response PTX influenza infection disease C-reactive SAA acute serum antiviral amyloid phase proteins Immunol. respiratory inflammatory {border-style bacterial binding human patients px;} #ffffff;} associated infections innate SAP Serum cell expression [], infected Infect. fish immune viruses Dis. Mantovani Res. clinical efficacy activity diseases high host long mice pentraxin potential vaccine Microbiol. []] concentrations hepatitis markers mouse pigs replication reported vaccination zebrafish Chen Clin.  Garlanda HCV J.M. Virol. Zhang administration analysis autophagy biomarkers border-color border-width caused combined cytokines different feline functions good inflammation inhibition liver microbial number observed outcome pathogens present profiles responses solid; use vaccines vivo {font-style {font-weight Biol. COVID- Influenza Lab. M.L. Markowska-Daniel Mol. Park Pentraxins Pomorska-Mol Thus, Viral action antibody antimicrobial assess body bold canine carcinoma centre chicken complement considered courier; em; fact, gene individuals inhibits interferon involved isoforms kwit level like model novel pathogen porcine pt;} reproductive resource similar studies subtype syncytial syndrome tract treatment undergoing up-regulation


Snapchat’s new Time Machine ageing filter is like FaceApp (but less controversial)
by Aatif SulleymanSnapchat has just released Time Machine, a new ageing lens that’s guaranteed to go viral. It lets you slide between looking really young and looking really old, and it’s a lot like FaceApp − but minus most of the privacy fears.
As you’d expect Time Machine a lot of fun to use, and it works through your phone’s selfie camera and front-facing snapper. And we all know what that means: hours spent terrorising your friends, of course!
Related: Best VPN
To access the Time Machine filter, take the following steps:
- Fire up your phone’s app store and reinstall the Snapchat app
- Spend a few minutes trying to remember your login details
- Once you’re in, tap the filter icon
- Select the option that shows a baby and an old person side by side (Time Machine is available on both iOS and Android)
The Snapchat app will give you a quick tutorial on how to use the filter, but it’s a case of slide left to go back in time, and slide right for a wrinkly fright.
Remember FaceApp? It was a summer sensation, and at one point it was near impossible to scroll down your Twitter or Instagram feed without catching a glimpse of a digitally aged (or de-aged) selfie.
However, people’s enthusiasm for the app quickly died after fears were raised that the app, which was launched by a Russian developer, had been harvesting users’ entire photo libraries.
Related: Best free VPN
There was, however, no evidence to suggest that this was indeed the case, and it’s likely that the rumour managed to spread so successfully because of the Russian connection.
Investigators did, however, find that FaceApp was uploading users’ pictures to servers located in the US for processing, rather than locally on the device − but then again this isn’t that unusual.
Unlike other sites, we thoroughly review everything we recommend, using industry standard tests to evaluate products. We’ll always tell you what we find. We may get a commission if you buy via our price links. Tell us what you think – email the Editor


About
We are half step . Music practice can be unfocused, filled with self-doubt, lonely, and disconnected from your goals and dreams. half step helps you climb higher by providing bite-sized tasks, near-peer support, and progress tracking.
We are half step . Music practice can be unfocused, filled with self-doubt, lonely, and disconnected from your goals and dreams. half step helps you climb higher by providing bite-sized tasks, near-peer support, and progress tracking.


Hello world!
This is the Java Full stack training bootcamp
make sure to brng your own laptops durng the bootcamp
Technologies
HTML
CSS
javascript
java
Firstname
Lastname
Age
Jill
Smith
50
Eve
Jackson
94
John
Doe
80


Andrew Scott Crerar
Most recent activity
Latest blog hotness
I recently went through the setup of my favorite OS, Arch Linux, on a 2011 Macbook Air (Model: A1369) and decided to keep the Apple bootloader. There are a number of reasons why you might want to keep the Apple bootloader vs. going down the rEFIt route... Read more
Get in touch
Have an idea? Need help? Let's chat :)


interface ComponentProvider<out TComponent>
Defines a provider of TComponent instances.
abstract val component: TComponent
The component that this provider is responsible for. |
class MemoizedComponentProvider<out TComponent> : ComponentProvider<TComponent>
An implementation of ComponentProvider that will cache the component after initialisation. |


|
Solinfra |
|---|
Carrot is an architecture-free neural network library built around neuroevolution
Why / when should I use this?
Whenever you have a problem that you:
You can use Carrot's ability to design networks of arbitrary complexity by itself to solve whatever problem you have. If you want to see Carrot designing a neural-network to play flappy-bird check here
For Documentation, visit here
$ npm i @liquid-carrot/carrot
Carrot files are hosted by JSDelivr
For prototyping or learning, use the latest version here:
<script<EMAIL_ADDRESS>For production, link to a specific version number to avoid unexpected breakage from newer versions:
<script src="https://cdn.jsdelivr.net/npm/<EMAIL_ADDRESS>💡 Want to be super knowledgeable about neuro-evolution in a few minutes?
Check out this article by the creator of NEAT, Kenneth Stanley
💡 Curious about how neural-networks can understand speech and video?
Check out this video on Recurrent Neural Networks, from @LearnedVector, on YouTube
This is a simple perceptron:
.
How to build it with Carrot:
const architect = new Architect();
architect.addLayer(new InputLayer(4));
architect.addLayer(new DenseLayer(5, { activationType: RELUActivation }));
architect.addLayer(new OutputLayer(1));
const network = architect.buildModel();
Building networks is easy with 17 built-in layers You can combine them as you need.
const architect = new Architect();
architect.addLayer(new InputLayer(10));
architect.addLayer(new DenseLayer(10, { activationType: RELUActivation }));
architect.addLayer(new MaxPooling1DLayer(5, { activation: IdentityActivation }));
architect.addLayer(new OutputLayer(2, { activation: RELUActivation }));
const network = architect.buildModel();
Networks also shape themselves with neuro-evolution
const XOR = [
{ input: [0, 0], output: [0] },
{ input: [0, 1], output: [1] },
{ input: [1, 0], output: [1] },
{ input: [1, 1], output: [0] },
];
// this network learns the XOR gate (through neuro-evolution)
async function execute(): Promise<void> {
this.timeout(20000);
const network: Network = new Network(2, 1);
const initial: number = network.test(XOR);
await network.evolve({ iterations: 50, dataset: XOR });
const final: number = network.test(XOR);
expect(final).to.be.at.most(initial);
}
execute();
Or implement custom algorithms with neuron-level control
let Node = require("@liquid-carrot/carrot").Node;
let A = new Node(); // neuron
let B = new Node(); // neuron
A.connect(B);
A.activate(0.5);
console.log(B.activate());
This project exists thanks to all the people who contribute. We can't do it without you! 🙇
Thanks goes to these wonderful people (emoji key):
Luis Carbonell 💻 🤔 👀 📖 |
Christian Echevarria 💻 📖 🚇 |
Daniel Ryan 🐛 👀 |
IviieMtz ⚠ |
Nicholas Szerman 💻 |
tracy collins 🐛 |
Manuel Raimann 🐛 💻 🤔 |
This project follows the all-contributors specification. Contributions of any kind welcome!
Your contributions are always welcome! Please have a look at the contribution guidelines first. 🎉
To build a community welcome to all, Carrot follows the Contributor Covenant Code of Conduct.
And finally, a big thank you to all of you for supporting! 🤗
| Silver Patrons |
|---|
|
Solinfra |
| Bronze Patrons |
|---|
|
Kappaxbeta |
| Patrons |
|---|
|
DollarBizClub |
A special thanks to:
@wagenaartje for Neataptic which was the starting point for this project
@cazala for Synaptic which pioneered architecture free neural networks in javascript and was the starting point for Neataptic
@robertleeplummerjr for GPU.js which makes using GPU in JS easy and Brain.js which has inspired Carrot's development
Generated using TypeDoc


The basics of Structured Query Language, a relatively simple query language.
The Python Standard Library includes a module sqlite3, an API for data persistence via the SQLite - a simple disk-based database that doesn’t require a separate server process. Read the tutorial, and try the given examples. See if you can modify them in simple ways, and come with questions!
Also, check out the
DB Browser for SQLite - we’ll
emphasize using sqlite3
from Python so we can do things
programmatically, but it is encouraged to install the DB Browser as a
helpful utility for ad hoc inspection and querying.
We’ll work together with SQLite in Python, making and exploring a simple database and trying a range of basic queries. Focus will be on the following SQL keywords:
SELECT
- how we choose which columns to getWHERE
- how we set conditions on the rows to be returned
LIMIT
- when we only want a certain number of rowsORDER
- when we want to sort the outputJOIN
- when we need data from multiple tables combined
We’ll also learn about how to use CREATE TABLE
to specify a
schema for our data, and INSERT
statements to put data into a
table. And lastly, we’ll learn how to calculate some basic statistics with
COUNT()
, AVG()
, and SUM()
,
organized using the keyword GROUP
.
This directory contains a file rpg_db.sqlite3
, a database for
a hypothetical webapp role-playing game. This test data has
dozens-to-hundreds of randomly generated characters across the base
classes (Fighter, Mage, Cleric, and Thief) as well as a few Necromancers.
Also generated are Items, Weapons, and connections from characters to
them. Note that, while the name field was randomized, the numeric and
boolean fields were left as defaults.
Use sqlite3
to load and write queries to explore the data,
and answer the following questions:
You do not need all the tables - in particular, the
account_*
, auth_*
, django_*
, and
socialaccount_*
tables are for the application and do not
have the data you need. the charactercreator_*
and
armory_*
tables and where you should focus your attention.
armory_item
and charactercreator_character
are
the main tables for Items and Characters respectively - the other tables
are subsets of them by type (i.e. subclasses), connected via a key (item_id
and character_id
).
You can use the DB Browser or other tools to explore the data and work on
your queries if you wish, but to complete the assignment you should write
a file rpg_queries.py
that imports sqlite3
and
programmatically executes and reports results for the above queries.
Some of these queries are challenging - that’s OK! You can keep working on them tomorrow as well (we’ll visit loading the same data into PostgreSQL). It’s also OK to figure out the results partially with a query and partially with a bit of logic or math afterwards, though doing things purely with SQL is a good goal. Subqueries and aggregation functions may be helpful for putting together more complicated queries.
Load the data (use pandas
) from the provided file
buddymove_holidayiq.csv
(the
BuddyMove Data Set) - you should have 249 rows, 7 columns, and no missing values. The data
reflects the number of place reviews by given users across a variety of
categories (sports, parks, malls, etc.).
Using the standard sqlite3
module:
buddymove_holidayiq.sqlite3
df.to_sql
(documentation) to insert the data into a new table review
in the
SQLite3 database
Then write the following queries (also with sqlite3
) to test:
Nature
in the
category also reviewed at least 100 in the
Shopping
category?
Your code (to reproduce all above steps) should be saved in
buddymove_holidayiq.py
, and added to the repository along
with the generated SQLite database.
For a more complicated example SQLite database with a number of tables to play with, check out this SQLite Sample Database.
The RPG data also exists in a
JSON file
- try loading it with the standard
json module,
and reproducing the above queries with direct manipulation of the Python
dictionaries. Also, try to load it into a pandas
dataframe
and reproduce the above queries with appropriate dataframe function calls.
This database is part of a Django (Python webapp framework) application,
the
Django-RPG
- check it out, and (though this is very much a stretch goal) you can
get started with Django
and see if you can run it (definitely use pipenv
!). If you
are able to, then you can use the the
Django ORM
(object-relational mapping, a way to interact with SQL through programming
language objects), and
query
the data. You’ll find that the questions we answered with pure SQL are
remarkably simple to answer using the ORM.
If you need one more stretch goal - the RPG data was generated using django-autofixture, a tool that facilitates tests by randomly generating data. Check it out, and if you got Django working, see if you can generate more data.


Spent
Sign In
Cancel
Getting Yourself On Track
Empowering you to invest in the things are important in your life
Spent
Sign Out
My Dashboard
Transaction Amount:
Transaction Details:
Add Transaction
Transaction List:
Total Spendings:
Last 24 Hours:
Last 7 Days:
Last 30 Days:
All Time:
Last 24 Hours
Last 7 Days
Last 30 Days
All Time


Dart Programming Language Tutorial Part 5 | Built-In Types Part 1
Sep 4, 2018 21:30 · 710 words · 4 minute read
In this post we will discuss some of the built-in types in dart. We will cover numbers, strings, and booleans. Let’s get started.
Built-in Types
What are built-in types? These are the types that a variable can be of and are already defined in dart i.e. built into dart programming language by default. Does that mean we can have our own custom types too ? Yes, we can. So dart is an object oriented programming language, and everything is an object. Every variable in Dart refers to an object i.e. it is an instance of a class. To make our custom type we just need to make sure the variable is an object, an instance of a class that we wrote, and that is how we can have our own type of variables. Pretty cool ha..!!!. We will look into creating classes and objects later on, for now let’s stick to these built-in types and discuss these in detail. There are two parts of this post, in this one we will discuss about numbers, strings, and booleans and we will conclude the rest of them in the next one.
Numbers
Numbers are used to store umm… numbers. Numbers can be any positive, negative or zero number. In Dart numbers are represented by either int
or double
. Int is to integers i.e. numbers without decimals while Double is to store decimal numbers or floating point numbers. Let’s see an example
int a = -2;
int b = 3;
int c = 0;
double e = -2.5;
double f = 0.0;
double g = 1.5;
So this is how we use int
and double
in our Dart code. We have already used int
before and will be using double
in coming posts.
Booleans
Booleans are as straight forward as it can be. If you need to store a true
or false
flag in your variable, you would use a boolean type of variable. To declare a variable boolean we would use bool
. We will revisit bool again while dealing with if-else
, but for the scope of this artice, I guess that is all to know about booleans.
bool isItRaining = true;
bool isItSunny = false;
String
Next on list, and the last one for this post is Strings. Strings are a single or group of characters. It can be a letter or a number or group of combination of both. It can also include symbols like !@#$%^&*
. Strings are very useful to store text data. To declare a string you would use String
to declare a variable (notice the use of capital S). The text that is assigned to a string variable has to be wrapped in quotes . It can be either single quote, double quote or triple quotes. Let’s look at those declarations
String str = 'This is a string';
String str1 = "This is another string";
String str2 = ''' This is a multi line string
which I can continue in different lines
which provides easy formatting''';
Over here we see all three types of string declarations. The declaration with single quotes and double quotes are pretty much the same. We would wrap the text in single or double quotes and that is it. The declaration with triple quotes are interesting because here we can write in multiline. We can use line breaks, put spaces whereevr and however we want. This becomes really handy when you are writting long database queries. Multi-line strings can also be declared using """
, using three single quotes is not mandatory. So we can also do something like this
String str = """ This
is also a valid multi line string """;
That’s it for this one, there are some more things to cover in Strings which we will cover shortly. See you in the next one.
There you go guys, you made it to the end of the blog. Please check out the video below if you still have any doubts. Subscribe to my youtube channel and my mailing list below for regular updates. Follow me on twitter , drop me a mail or leave a comment here if you still have any doubts and I will try my best to help you out. Thanks
Stay tuned and see you around :)
- Hackerrank | Solution of Migratory Birds in Golang
- Hackerrank | Solution of Divisible Sum Pairs in Golang
- From The AGC to Smartphones and Beyond
- Hackerrank | Solution of Birthday Chocolate in Golang
- Hackerrank | Solution of Breaking the Records in Golang
- Hackerrank | Solution of Between Two Sets in Golang
- New Mornings New Subscribers
- They Can Smell What You are Cooking
- Hackerrank | Solution of Apple and Orange in Golang
- PUBG: A New Gaming Sensation


The Jetty microservice comes with a bare-bones jetty.xml file which can be modified to suite any needs.
The jetty.xml can be located in either the "." or "files" working directory or classpath.
It can also be specified in any of the following ways:
-
Using the {@link oaj.microservice.jetty.JettyMicroservice.Builder#jettyXml(Object,boolean)} method to specify the location or contents
of the file.
-
Specifying the location using a Jetty-Config value in the MANIFEST.MF file.
| Jetty-Config: files/jetty.xml
-
Specifying the location using the "Jetty/jettyXml" configuration value.
| #=======================================================================================================================
| # Jetty settings
| #=======================================================================================================================
| [Jetty]
|
| # Path of the jetty.xml file used to configure the Jetty server.
| config = files/jetty.xml
SVL variables in the jetty.xml file are automatically resolved by the microservice.
This allows you to reference values in your configuration file from the jetty.xml file.
The HTTP port used is controlled via the following:
-
The {@link oaj.microservice.jetty.JettyMicroservice.Builder#ports(int...)} method.
| JettyMicroservice
| .create()
| .args(args)
| .servlets(RootResource.class)
| .port(1000,2000,0,0,0) // Try port 1000, then 2000, then 3 random ports.
| .build()
| .start()
-
The "Jetty/ports" configuration property.
| #=======================================================================================================================
| # Jetty settings
| #=======================================================================================================================
| [Jetty]
|
| # Port to use for the jetty server.
| # You can specify multiple ports. The first available will be used. '0' indicates to try a random port.
| port = 1000,2000,0,0,0
The first available port is then made available through the system property "availablePort" so that it
can be referenced in our jetty.xml file.
| <Set name="connectors">
| <Array type="org.eclipse.jetty.server.Connector">
| <Item>
| <New class="org.eclipse.jetty.server.ServerConnector">
| <Arg>
| <Ref refid="ExampleServer" />
| </Arg>
| <Set name="port">$S{availablePort,8080}</Set>
| </New>
| </Item>
| </Array>
| </Set>
The {@link oaj.microservice.jetty.JettyMicroservice.Builder#jettyServerFactory(JettyServerFactory)} method is also provided
to use your own customized Jetty server.


--- layout: post title: Episode 065 | Kathleen Dollard - Relentless Dedication link: http://traffic.libsyn.com/developeronfire/DeveloperOnFire-65-KathleenDollard.mp3 length: 50331648 speaker: Dave Rael duration: '52:43' subtitle: 'Developer On Fire: Kathleen Dollard' guest_name: Kathleen Dollard image: /assets/images/KathleenDollard.jpg guest_blog: https://mvp.microsoft.com/en-us/PublicProfile/6550?fullName=Kathleen%20Dollard guest_twitter<EMAIL_ADDRESS>disqus_url: http://developeronfire.com/Podcast/Episodes/kathleen-dollard-relentless-dedication episode_number: 65 redirect_from: - "/65/" - "/065/" - "/0065/" - "/kathleen-dollard-relentless-dedication/" - "/Kathleen-Dollard/" - "/KathleenDollard/" - "/Podcast/Episodes/65/" - "/Podcast/Episodes/065/" - "/Podcast/Episodes/0065/" - "/Podcast/Episodes/kathleen-dollard-relentless-dedication/" - "/Podcast/Episodes/Kathleen-Dollard/" - "/Podcast/Episodes/KathleenDollard/" guid: http://developeronfire.com:80/Podcast/Episodes/kathleen-dollard-relentless-dedication ---
Kathleen Dollard wants to teach you to code better. She wants to teach you more about the tools you use every day and the tools you aren’t yet using. Coding is her passion and debugging is her challenge - you’ll be happier if you do both better. Kathleen has written dozens of articles, spoken at conferences and user groups around the world, and pushes Microsoft to respond to your real world needs as a long time MVP. She is the Director of Engineering at Real in Denver (engageReal.com). She also has courses in the Pluralsight library and the library at WintellectNOW.
1. "Read the mail" - actually receive communication and know what they are communcating - listen rather than waiting for your turn to talk
2. Celebrate the growing skillsets of others
3.


Parser
The class Albatross.Expression.Parser implements interface Albatross.Expression.IParser. It performs the function of processing, evaluating and generating of expressions.
Design
The Parser class parses the expression by
- Tokenize the text
- Build a stack
- Create a token tree
Once the token tree is created, the parser can evaluate the result of the expression by evaluating the tree nodes recursively.
The implementation of the design supports the following functionalties:
- Tokens
- String Literal -
"yes"
- Numeric Literal -
100 + 4.0
- The NumericLiteralToken class handles number and it converts all numeric value to C# type
System.Double
.
- The NumericLiteralToken class handles number and it converts all numeric value to C# type
- Variable -
a + 4
- Parantheses -
4 * (1 + 2)
- String Literal -
- Infix operation - Operations with two operands and a operator in the middle:
1 + 2
- operation precedence
- unary operation - Negative sign:
-1
- prefix operation - Functions with fixed or optional parameter and a return value:
Now(), Left("Orange", 4)
- unlimited optional function parameters -
max(1,2,3,4,5)
- Array - Array is a special function that returns an array object:
@(1, 2, 3, 4, 5)
Tokenization
Tokenization reads the expression from left to right. Its function is to recognize individual components (tokens) of an expression. This step will throw TokenParsingException if the expression has errors. The resulting tokens are inserted into a queue. The implementation is in the Tokenize method of the Parser class.
Here are some examples:
- Expression:
4 + 5 * 6 - max(7, 1)
4
+
5
*
6
-
max
(
7
,
1
)
- Expression:
if (a > b, "Yes", "No")
if
(
a
>
b
,
"Yes"
,
"No"
)
Notice that comma and parentheses are considered as control tokens but the string boundary (double quote) are not. String boundaries are part of the string token and will be stripped and disgarded by the StringLiteralToken class during the evaluation process.
Create a Stack
This step converts the tokenized queue into a postfix stack using the Shunting-yard algorithm. The implementation is in the BuildStack method of the Parser class. A postfix stack is also called a Reverse polish notion.
Here are the top popping stack for the example above:
- Expression:
4 + 5 * 6 - max(7, 1)
-
max
1
7
$
+
*
6
5
4
- Expression:
if (a > b, "Yes", "No")
If
"No"
"Yes"
>
b
a
$
- Expression:
Format(Today(), "yyyy-MM-DD")
Format
"yyyy-MM-DD"
Today
$
$
A special control token $
is used to indicate the end of parameters for prefix operations. This allows functions with unknown number of optional parameters. It also simplify the tree creation logic because it doesn't need to know how many parameters the prefix function has.
Create a Tree
This step is to create a tree from the postfix stack. The process of converting a stack to a tree is the same process of evaluating (popping) the postfix stack. The tree is created so that the expression can be evaluated multiple times without rebuilding the stack. The result object is of type IToken.
Here are the trees for the example above:
- Expression:
4 + 5 * 6 - max(7, 1)
-
+
4
*
5
6
max
7
1
- Expression:
if (a > b, "Yes", "No")
If
>
a
b
"Yes"
"No"
- Expression:
Format(Today(), "yyyy-MM-DD")
Format
Today
"yyyy-MM-DD"
Evaluate a tree
With a tree built, the evaluation process is a simple recursive call to the EvalValue function of the IToken interface.
Regenerate the expression
Using the same IToken object, the parser can regenerate the original expression or convert it to an expression of different format by calling the EvalText method. The default EvalText method will produce an expression string with equal functionality as the original with consistent spacing and mininum usage of parantheses. For example: if the original expression is 1+(2*3)
, the regenerated expression will be: 1 + 2 * 3
.
Use of variable in an expression
When evaluating expressions with variables, the EvalValue has a second parameter of type Func<object, string>
that can be used to return the value of a variable. Here is an example:
[TestCase("a + b * c", ExpectedResult = 7)]
[TestCase("a + b + c", ExpectedResult =6)]
public object Run(string expression) {
Func<string, object> func = name => {
switch (name.ToLower()) {
case "a":
return 1;
case "b":
return 2;
case "c":
return 3;
default:
return null;
}
};
IParser parser = Factory.Instance.Create();
return parser.Compile(expression).EvalValue(func);
}


super-rsu¶
SYNOPSIS¶
super-rsu [-h] [-n] [--verify] | [ [--log-level {trace,debug,error,warn,info,notset}]
[--log-file <filename>] [--rsu-only] [--with-rsu] [--force-flash] ]
rsu_config
DESCRIPTION¶
super-rsu is a tool that can be used for flashing image files and commanding an Intel PAC device to perform RSU (remote system update - or a board reboot). Performing an RSU on an Intel PAC device will cause it to reload any firmware or programmable logic and restart its execution, a requirement for any updated firmware or programmable logic to take effect.
At the core of super-rsu is its configuration file (referred to in this document as ‘rsu_config’) which is essentially a manifest file for identifying both the target device and the binary images (and their versions) to be flashed.
At a high level, the flow of super-rsu should be:
Read and parse rsu_config file
Use product identifiers (like vendor, device and any additional vendor, device pairs that may be present in the PCIe bus) to locate all compatible devices on the PCIe bus.
For every device found on the system, update the device using the flash images defined in the “flash” section in the rsu_config data (or nvmupdate section). Each item in the “flash” section is a “flash spec” that contains:
The flash type (“user”, “bmc_fw”, “bmc_img”, …)
The filename of the image to flash. super-rsu will look for this file first in the same directory of the rsu_config file, and then look in the current working directory.
The version of the image.
An optional “force” indicator
An optional “requires” indicator The “nvmupdate” section is used to describe an Ethernet firmware file and its version.
Using the data in the “nvmupdate” and “flash” sections, the update routine involves:
If an “nvmupdate” section is present:
Locate the file on the file system to use to flash the Ethernet device.
Call nvmupdate to get an “inventory” of devices matching the vendor and device id in this section.
Use this data to dynamically generate an nvmupdate compatible configuration file.
Call nvmupdate with the generated configuration file to flash the Ethernet interfaces in the Vista Creek card (if version reported by system does not match the version in this section).
For each spec in the “flash” section:
Locate the file on the file system to use to flash.
Compare the version listed in the “flash spec” to version reported by the target component.
Create a task to call fpgaflash if either of the following conditions is met (and the revision specified is compatible):
The “force” indicator is present and set to true.
The version in the spec does not match the version reported by the system OR the flash type is factory type.
For each task created from the “flash” section:
Call fpgaflash with the command line arguments that correspond to the flash type and the file name in the spec used to create the task. This opens and controls the execution of fpgaflash in another process.
NOTE: If the system reports a revision for one of the components being flashed, this revision must be in the set of revisions listed in the manifest. Example: if the system reports ‘a’ for bmc_img and the manifest includes ‘ab’, then the image will be flashed.
NOTE: Each update routine is run in a thread specific to a device located
on the PCIe bus. Every task in an update routine involves opening a new process
that is controlled and managed by its update routine thread.
If a task includes a timeout and the timeout is reached, a termination request
will be sent to its process and it will be counted as a failure. If a global
timeout is reached in the main thread, a termination request will be sent to each
thread performing the update. Consequently, the update routine will give the
current task extra time before terminating the process.
The RSU operation will only be performed if requested with either --with-rsu
command line argument or with the --rsu-only
command line argument.
The former will perform the RSU command upon successful completion of flash
operations. The latter will skip the process of version matching and flashing
images and will only perform the RSU command. It is recommended that super-rsu
be executed again if any flash operation is interrupted.
POSITIONAL ARGUMENTS¶
rsu config
Specifies the name of the file containing the RSU configuration (in JSON format)
OPTIONAL ARGUMENTS¶
-h, --help
Print usage information.
--verify
Compare versions of flashable components on the system against the manifest. Return non-zero exit if compatible components are not up to date.
-n, --dry-run
Don’t perform any updates, just a dry run. This will print out commands that can be executed in a Linux shell.
--log-level {trace,debug,error,warn,info,notset}
Log level to use. Default is ‘info’.
`–log-file
Emit log messages (with DEBUG level) to filename NOTE: The default log file (/tmp/super-rsu.log) is set to rollover every time super-rsu is executed. This will create numbered backups before truncating the log file. The maximum number of backups is 50.
--rsu-only
Only perform the RSU command.
--with-rsu
Perform RSU after updating flash components(experimental)
--force-flash
Flash all images regardless of versions matching or not.
CONFIGURATION¶
The following is the JSON schema expected by super-rsu. Any deviance from this schema may result in errors executing super-rsu.
{
"definitions": {},
"$schema": "http://json-schema.org/draft-07/schema#",
"$id": "http://example.com/root.json",
"type": "object",
"title": "The Root Schema",
"required": [
"product",
"vendor",
"device",
"flash"
],
"optional": [
"nvmupdate",
],
"properties": {
"product": {
"$id": "#/properties/product",
"type": "string",
"title": "The Product Schema",
"default": "",
"examples": [
"n3000"
],
"pattern": "^(.*)$"
},
"vendor": {
"$id": "#/properties/vendor",
"type": "string",
"title": "The Vendor Schema",
"default": "",
"examples": [
"0x8086"
],
"pattern": "^((0x)?[A-Fa-f0-9]{4})$"
},
"device": {
"$id": "#/properties/device",
"type": "string",
"title": "The Device Schema",
"default": "",
"examples": [
"0x0b30"
],
"pattern": "^((0x)?[A-Fa-f0-9]{4})$"
},
"nvmupdate": {
"$id": "#/properties/nvmupdate",
"type": "object",
"title": "The nvmupdate Schema",
"required": [
"vendor",
"device",
"filename",
"version"
],
"optional": [
"interfaces"
],
"properties": {
"vendor": {
"$id": "#/properties/nvmupdate/vendor",
"type": "string",
"title": "The nvmupdate Vendor Schema",
"default": "",
"examples": [
"0x8086"
],
"pattern": "^((0x)?[A-Fa-f0-9]{4})$"
},
"device": {
"$id": "#/properties/nvmupdate/device",
"type": "string",
"title": "The nvmupdate Device Schema",
"default": "",
"examples": [
"0x0d58"
],
"pattern": "^((0x)?[A-Fa-f0-9]{4})$"
},
"interfaces": {
"$id": "#/properties/nvmupdate/interfaces",
"type": "number",
"title": "The nvmupdate Interfaces Schema",
"default": "1",
"examples": [
2, 4
]
},
"filename": {
"$id": "#/properties/nvmupdate/filename",
"type": "string",
"title": "The nvmupdate Filename Schema",
"default": "",
"examples": [
"PSG_XL710_6p80_XLAUI_NCSI_CFGID2p61_Dual_DID_0D58_800049C6.bin"
],
"pattern": "^(.*)$"
},
"version": {
"$id": "#/properties/nvmupdate/version",
"type": "string",
"title": "The nvmupdate Version Schema",
"default": "",
"examples": [
"800049C6"
],
"pattern": "^((0x)?[A-Fa-f0-9]{8})$"
},
"timeout": {
"$id": "#/properties/nvmupdate/timeout",
"type": "string",
"title": "The Timeout Schema",
"default": "",
"examples": [
"10m"
],
"pattern": "^([0-9]+(\\.[0-9]+)?([dhms]))+$"
}
}
},
"flash": {
"$id": "#/properties/flash",
"type": "array",
"title": "The Flash Schema",
"items": {
"$id": "#/properties/flash/items",
"type": "object",
"title": "The Items Schema",
"required": [
"filename",
"type",
"version",
"revision"
],
"optional": [
"enabled",
"force",
"timeout",
"requires"
],
"properties": {
"enabled": {
"$id": "#/properties/flash/items/properties/enabled",
"type": "boolean",
"title": "The Enabled Schema",
"default": "true"
},
"filename": {
"$id": "#/properties/flash/items/properties/filename",
"type": "string",
"title": "The Filename Schema",
"default": "",
"examples": [
"vista_creek_qspi_xip_v1.0.6.ihex"
],
"pattern": "^(.*)$"
},
"type": {
"$id": "#/properties/flash/items/properties/type",
"type": "string",
"title": "The Type Schema",
"default": "",
"examples": [
"bmc_fw"
],
"enum": ["user", "bmc_fw", "bmc_img", "dtb", "factory_only",
"phy_eeprom"]
},
"version": {
"$id": "#/properties/flash/items/properties/version",
"type": "string",
"title": "The Version Schema",
"default": "",
"examples": [
"1.0.6"
],
"pattern": "^\\d+\\.\\d+\\.\\d+$"
},
"force": {
"$id": "#/properties/flash/items/properties/force",
"type": "boolean",
"title": "The Force Schema",
"default": false,
"examples": [
true
]
},
"revision": {
"$id": "#/properties/flash/items/properties/revision",
"type": "string",
"title": "The Revision Schema",
"default": "",
"examples": [
"C"
],
"pattern": "^([A-Za-z])$"
},
"timeout": {
"$id": "#/properties/nvmupdate/timeout",
"type": "string",
"title": "The Timeout Schema",
"default": "",
"examples": [
"10m"
],
"pattern": "^([0-9]+(\.[0-9]+)?([dhms]))+$"
},
"requires": {
"$id": "#/properties/flash/items/properties/requires",
"type": "string",
"title": "The Requires Schema",
"default": "",
"examples": [
"bmc_img >= 1.0.12"
],
"pattern": "^(([a-z_]+) ((<>!=)?=) ([0-9a-z\\.]+)$"
}
}
}
}
}
}


Provides serialization for Avro generic records while using Kryo serialization.
Provides serialization for Avro schemas while using Kryo serialization.
Provides serialization for Avro specific records while using Kryo serialization.
Serializable container for wrapping objects using Kryo.
Kryo specification that adds avro schema, generic record, and specific record serialization support.
Constructors for wrapping objects with a java-serializable container using Kryo.
Package containing utility classes related to serialization of data during a KijiExpress flow. Includes components for integrating avro and kryo serialization.


Employee Details
Meal Selection
Defaulters
Defaulter Information
sid
Name
Employed Store
Employer Name
DefaulterReason
{{student.sid}}
{{student.name}}
{{student.employee_store}}
{{student.employee_head}}
{{student.defaulterReason}}


An IP address is hierarchical, and made by 2 parts: the network and the host part. The network part is used by each host to decide if the destination is in their local network or if it's remote.
So far we've simplified, by assuming that the first 3 decimals were the network part and the last one was the host part.
It could very well be that <IP_ADDRESS> and <IP_ADDRESS> belong in the same network (same network part)!
So how does the host know which is the network part of an address? Thanks to the binary representation of the address and the subnet mask.
The network part is the portion of the address 32-bit stream that represents the network the address belongs to.
This leads to being more difficult trying to identify the network part just by looking at the decimal dotted notation.
To separate the bits belonging to the two parts in the 32 bits, we use the subnet mask, which is also 32 bit long and made of consecutive 1s, followed by consecutive 0s.
The 1s represent the network part, the 0s the host part.
An IP address always needs a subnet mask associated to it. The host does an operation called bitwise AND between the two to determine what the (sub)network is.
Address: <IP_ADDRESS> 11000000.10101000.00000001. 11001000 Netmask: <IP_ADDRESS> = 24 11111111.11111111.11111111. 00000000 => [---------NETWORK---------] [-HOST-] Address: <IP_ADDRESS> 11000000.10101000.00000001. 11001000
Address: <IP_ADDRESS> 10101100.0001 0000.00000010.00000100 Netmask: <IP_ADDRESS> = 12 11111111.1111 0000.00000000.00000000 => [--NETWORK--] [--------HOST--------] Address: <IP_ADDRESS> 10101100.0001 0000.00000010.00000100
Address: <IP_ADDRESS> 10101100.0001 0010.00111010.00001001 Netmask: <IP_ADDRESS> = 12 11111111.1111 0000.00000000.00000000 => [--NETWORK--] [--------HOST--------] Address: <IP_ADDRESS> 10101100.0001 0010.00111010.00001001
For convenience, the subnet mask can also be represented as dotted decimal and therefore looks like an IPv4 address.
The subnet mask doesn't contain the network park itself. It just provides the host with a way to figure it out.
Another, more compact way to express the subnet mask is through the prefix length (or network prefix) and the slash notation.
Prefix length is the number of 1s in the subnet mask. We write the IP address, followed by a slash ("/") and then by the prefix length, as in <IP_ADDRESS>/24.
| Binary Mask | Prefix Length | Subnet Mask |
11111111 00000000 00000000 00000000 |
/8 |
<IP_ADDRESS> |
11111111 10000000 00000000 00000000 |
/9 |
<IP_ADDRESS> |
11111111 11000000 00000000 00000000 |
/10 |
<IP_ADDRESS> |
11111111 11100000 00000000 00000000 |
/11 |
<IP_ADDRESS> |
11111111 11110000 00000000 00000000 |
/12 |
<IP_ADDRESS> |
11111111 11111000 00000000 00000000 |
/13 |
<IP_ADDRESS> |
11111111 11111100 00000000 00000000 |
/14 |
<IP_ADDRESS> |
11111111 11111110 00000000 00000000 |
/15 |
<IP_ADDRESS> |
11111111 11111111 00000000 00000000 |
/16 |
<IP_ADDRESS> |
11111111 11111111 10000000 00000000 |
/17 |
<IP_ADDRESS> |
11111111 11111111 11000000 00000000 |
/18 |
<IP_ADDRESS> |
11111111 11111111 11100000 00000000 |
/19 |
<IP_ADDRESS> |
11111111 11111111 11110000 00000000 |
/20 |
<IP_ADDRESS> |
11111111 11111111 11111000 00000000 |
/21 |
<IP_ADDRESS> |
11111111 11111111 11111100 00000000 |
/22 |
<IP_ADDRESS> |
11111111 11111111 11111110 00000000 |
/23 |
<IP_ADDRESS> |
11111111 11111111 11111111 00000000 |
/24 |
<IP_ADDRESS> |
11111111 11111111 11111111 10000000 |
/25 |
<IP_ADDRESS> |
11111111 11111111 11111111 11000000 |
/26 |
<IP_ADDRESS> |
11111111 11111111 11111111 11100000 |
/27 |
<IP_ADDRESS> |
11111111 11111111 11111111 11110000 |
/28 |
<IP_ADDRESS> |
11111111 11111111 11111111 11111000 |
/29 |
<IP_ADDRESS> |
11111111 11111111 11111111 11111100 |
/30 |
<IP_ADDRESS> |
11111111 11111111 11111111 11111110 |
/31 |
<IP_ADDRESS> |
11111111 11111111 11111111 11111111 |
/32 |
<IP_ADDRESS> |
Within the range of addresses belonging to an IPv4 (sub)network, we can identify 3 types:
:~$ # EXAMPLE 1
:~$ ipcalc <IP_ADDRESS>/24
Address: <IP_ADDRESS> 00001010.00000001.00000001. 00000000
Netmask: <IP_ADDRESS> = 24 11111111.11111111.11111111. 00000000
=>
Network: <IP_ADDRESS>/24 00001010.00000001.00000001. 00000000
HostMin: <IP_ADDRESS> 00001010.00000001.00000001. 00000001
HostMax: <IP_ADDRESS> 00001010.00000001.00000001. 11111110
Broadcast: <IP_ADDRESS> 00001010.00000001.00000001. 11111111
Hosts/Net: 254
:~$ # EXAMPLE 2
:~$ ipcalc <IP_ADDRESS>/16
Address: <IP_ADDRESS> 10101100.00010010. 00000000.00000000
Netmask: <IP_ADDRESS> = 16 11111111.11111111. 00000000.00000000
=>
Network: <IP_ADDRESS>/16 10101100.00010010. 00000000.00000000
HostMin: <IP_ADDRESS> 10101100.00010010. 00000000.00000001
HostMax: <IP_ADDRESS> 10101100.00010010. 11111111.11111110
Broadcast: <IP_ADDRESS> 10101100.00010010. 11111111.11111111
Hosts/Net: 65534
:~$ # EXAMPLE 3
:~$ ipcalc <IP_ADDRESS>/28
Address: <IP_ADDRESS> 11000000.10101000.00000010.0001 0000
Netmask: <IP_ADDRESS> = 28 11111111.11111111.11111111.1111 0000
=>
Network: <IP_ADDRESS>/28 11000000.10101000.00000010.0001 0000
HostMin: <IP_ADDRESS> 11000000.10101000.00000010.0001 0001
HostMax: <IP_ADDRESS> 11000000.10101000.00000010.0001 1110
Broadcast: <IP_ADDRESS> 11000000.10101000.00000010.0001 1111
Hosts/Net: 14
:~$ # EXAMPLE 4
:~$ ipcalc <IP_ADDRESS>/24
Address: <IP_ADDRESS> 00001010.01010111.00010111. 01111011
Netmask: <IP_ADDRESS> = 24 11111111.11111111.11111111. 00000000
=>
Network: <IP_ADDRESS>/24 00001010.01010111.00010111. 00000000
HostMin: <IP_ADDRESS> 00001010.01010111.00010111. 00000001
HostMax: <IP_ADDRESS> 00001010.01010111.00010111. 11111110
Broadcast: <IP_ADDRESS> 00001010.01010111.00010111. 11111111
Hosts/Net: 254
Any host on a IPv4 network needs an IPv4 Address, a Subnet Mask and a default gateway to fully operate. These parameters could be obtained manually or automatically.
Any host on a IPv4 network needs an IPv4 Address, a Subnet Mask and a default gateway to fully operate. These parameters could be obtained manually or automatically.
As we've seen, transmissions can be unicast, multicast or broadcast depending on those who will receive and process the content. IPv4 networks have all these 3 types.
Unicast is used for normal host-to-host communication in a client/server of P2P fashion.
Host addresses that are source and destination addresses of a unicast transmission are considered unicast addresses.
The IPv4 range for unicast addresses is <IP_ADDRESS> - <IP_ADDRESS>, but inside there are many reserved subranges.
Unicast packets can be routed throughout networks.
Using the broadcast address of the network, it is possibile to send packets to all its hosts (the broadcast domain).
Each hosts will process the packet like it was sent to its unicast address, so the broadcast address is an address that is "common" to every host on the network.
Broadcast packets are not routed by default, and stay confined in the local network. This means routers define the boundaries of the broadcast domain.
With multicast transmission, an host can communicate with any subset of hosts without having to send multiple unicast packets or overreaching with a broadcast packet.
Hosts interested in participating in a multicast communications joins the multicast group, and then the multicast protocols will ensure packet flows to all subscribing hosts.
Multicast groups are represented by IPv4 addresses.
A public IPv4 address is a unicast address that is routable on the Internet. This means it can be a source or destination address of a packet appearing on the public Internet and can be included in the routing table of Internet routers.
RFC 1918 defines 3 ranges of IPv4 addresses that are not meant to be Internet routable, and are therefore referred to as private.
Unlike public addresses, these are not meant to be globally unique, but they must be within each private networks.
Packets from private networks must be blocked or NATted by perimeter routers before reaching the Internet.
The RFC 1700 divides the unicast ranges into classes, specified in terms of network size and assigned specific IP blocks.
Classful addressing refers to the (legacy) practice of assigning an entire network from one of this pre-defined classes.
Classful addressing was highly inefficient, leading to many wasted addresses, so it was progressively abandoned.
Classless addressing, also known as Classless Inter-Domain Routing (CIDR), allows to allocate address ranges from the public space with prefix lengths other than /8, /16 or /24.
The various blocks of available public IPv4 addresses are assigned by the IANA, who delegates Regional Internet Registries to manage assignments in different areas.
IP addresses are allocated to ISPs by the RIRs. Most "final users" (companies, organizations, inviduals) borrow their Internet addresses from the ISP as part of some service.
All these addresses must never appear on the public Internet.


This page will tell you the delay between your hover/ Click − Hover = Click − Touchstart =
Click − Hover = Click − Touchstart =
Normal link
Big link
Click me
Click me
Click − Mousedown =
Click − Mousedown =


#0A837F
Sidebar (main menu)
#076461
Links and Headers
#000000
Main text
#FF3D00
Publish dates
#EFEFEF
Background color


Find your nearest health service, including GPs, pharmacies and A&E.
Order repeat prescriptions and check prescription costs.
Includes how to book GP appointments and register as an organ donor.
Answer your questions about how to access NHS services.
How to access your health records and choose how your information is used or shared.
Book, cancel or change a referral appointment.
Includes help with eye tests, glasses, dental costs and low income needs.


Research interests
Until several weeks ago I was a consultant at Deloitte involved in a variety of supply chain projects including KPI and dashboard implementation, process optimisation, organizational design, value stream mapping and writing. I am interested in the field of supply chain management, Strategic Management, Market Analysis, Marketing.
I hold a master's degree in management from the Louvain School of Management and a master's degree in communication of organizations from the Catholic University of Louvain in Belgium.
Education
- Louvain School of Management, Master in Management, -Louvain, Belgium-, 2014 - 2016
Master's degree final dissertation: "Merger & acquisition: A case study - The acquisition of Lucas film by Disney"
- Catholic University of Louvain, Master in Communication and Public Relations, -Louvain, Belgium-, 2012 - 2014
Master's degree final dissertation: "Confucianism and its impact on Asian and Korean companies"
- Pai-Chai University, Korean Language courses, -Daejeon, South Korea-, 2011 - 2012
- Algiers University III, Bachelor Degree in Communication and Public Relations, -Algiers, Algeria-, 2007 - 2011
Work Experience
-
Consultant at Deloitte , Algiers, Algeria
April 2016 - September 2017
During this experience, I worked on consulting missions to Algerian and foreign companies, in Algeria and sometimes abroad. My tasks were as follows:
Strategy consulting:
- Conduct targeted market research and positioning
- Business SWOT Analysis
- Marketing and prospective study
- Conduct of international benchmarks
Management consulting:
- Operational e ciency: Review and development of operational processes (RACI, owcharts), design and implementation of dashboards and reporting
- Organization: Design of organizational structures, development of job descriptions and logigrams of supply chain target processes Change
- Marketing and prospective study
- Change Management: Communication and Training Plans
-
Intern at Cheil Worldwide , Zaventem, Belgium
January 2014 - June 2014
During this experience, I worked on a marketing strategy.My tasks were as follows :
Strategic Marketing:
- Conducting SWOT and PESTEL analysis
- Conducting targeted market research on HNWI (High Net Worth Individuals)
- Establishing a marketing strategy in purpose of changing the client brand perception in Belgium
- Intern, MBC Media Group, Dubai, UAE, Jully - August 2008
- Volunteer, FOREM, Algeirs, Algeria, 2004 - Present
Skills
- Operational Skills: Market analysis, Team managment, Supply chain process optimization, Organizational diagnosis, Development of business proposals etc.
-
Languages:
- English (Fluent)
- French (Native)
- Arabic (Native)
- Korean (Notions)
- Programming Languages: HTML.
References
- Khadidja Kazitani, Senior Manager, Consulting, Deloitte<EMAIL_ADDRESS>- Guilhem Bascle, Professor, Strategic Management, Louvain School of Management<EMAIL_ADDRESS>Contact
Khiati Mohamed Fakhr-Eddine
E-mail<EMAIL_ADDRESS>Tel: (+971)-5-0538-1186
D.B.A Student
Canadian University Dubai
Dubai, UAE


If you have completed all steps correctly, there will now be an extra icon on the right hand side of your menu bar.
- The icon represents the keyboard you currently have activated.
- For example, if you are currently using the Australian keyboard an Australian flag will appear in your menu bar.
- By selecting this icon you are able to switch between the keyboards you have enabled in the previous steps.
- To switch to a Korean keyboard, select the current icon, and from the drop-down list select "2-Set Korean"
- Once selected, all output from your keyboard will be Korean symbols.


h2
We are a charitable organisation that has been formed by the community for the community. We endevour to support and provide guidance for the less fortunate and the unprivilaged in our society. This includes; refugees, asylum seekers and homeless people. As an arab group in Rochdale, we welcome all to our meetings and to get in touch. We are here for our community whenever, however, whatever the circumstances.
Dr Souhad Sharif and Wafa Takheroubt:
We are here for our community. A few examples of the enormous things that we have helped to organise with the hiraculous efforts of our volunteers:


frost climate rings blue cold ring growing seed spring (Fig. damage tree change position provenances fall populations {border-style px;} #ffffff;} growth degree season adaptation days northern assisted data temperature trees migration pine provenance species Frost Nature Supplementary Table genetic test °C annual sections sites year Interior cells events intensity micro px; sources study {font-family Climate Ecol. Hamann Julian Res. colder effects end font-size forest intensities light occurrence planting population risks transfer wood (Supplementary Assisted Blue British Can. Douglas-fir Southern United associated average calculated change. double; early earlywood field indicate lodgepole occurred package plant risk southern start sum susceptibility transfers tree-ring using χ² = ., ./nature Biol. Chang. For. Montwé Nat. North Spiecker Tree analyses anatomical b). border-color border-width changes conditions forests future geographic hardiness increase indicates labeled length linked material mortality p < ., reduce represent significance solid; spruce tested trial variables warm warm-adapted {font-style {font-weight ./s--- Bot. Canada Cold Commons Creative Evol. Fig Gail Glob. Growing Here, Isaac-Renton Pinus Provenances Simon States based bold changing clines common conducted conservation correlation courier; cumulative date day designed differences different drought em; example, experiments false formation frosts function garden grown heat high included layers levels limits maladaptation means models occurrences origin procedure productivity pt;} range regions remain response rings, selected significant site source susceptible taken tracheids used variation western


1 hospitalized, 1 in custody after domestic argument in Lauderhill ends in shooting
by 7 News WSVNLAUDERHILL, FLA. (WSVN) - Police have taken one person into custody after, they said, a domestic argument at a Lauderhill home ended in a shooting that sent one male victim to the hospital.
Lauderhill Police and Fire Rescue units have responded to the scene in the area of Northwest 46th Street and 66th Avenue, just before 5:45 p.m., Sunday.
According to investigators, the incident unfolded both inside and outside of the home.
Paramedics have taken the victim to Broward Health Medical Center in Fort Lauderdale with facial injuries. He is listed in critical condition, but he was alert and talking during transport.
Detectives are trying to determine the nature of the argument that led to the shooting, as they continue to investigate.