Socket.io enables Node.js developers to support real-time communication using WebSockets in modern browsers and legacy fallback protocols in older browsers

Modern web applications such as Facebook, Twitter, or Gmail are incorporating real-time capabilities, which enable the application to continuously present the user with recently updated information. Unlike traditional applications, in real-time applications the common roles of browser and server can be reversed since the server needs to update the browser with new data, regardless of the browser request state. This means that unlike the common HTTP behavior, the server won't wait for the browser's requests. Instead, it will send new data to the browser whenever this data becomes available.

This reverse approach is often called Comet, a term coined by a web developer named Alex Russel back in 2006 (the term was a word play on the AJAX term; both Comet and AJAX are common household cleaners in the US). In the past, there were several ways to implement a Comet functionality using the HTTP protocol.

The first and easiest way is XHR polling. In XHR polling, the browser makes periodic requests to the server. The server then returns an empty response unless it has new data to send back. Upon a new event, the server will return the new event data to the next polling request. While this works quite well for most browsers, this method has two problems. The most obvious one is that using this method generates a large number of requests that hit the server with no particular reason, since a lot of requests are returning empty. The second problem is that the update time depends on the request period. This means that new data will only get pushed to the browser on the next request, causing delays in updating the client state. To solve these issues, a better approach was introduced: XHR long polling.

In XHR long polling, the browser makes an XHR request to the server, but a response is not sent back unless the server has a new data. Upon an event, the server responds with the event data and the browser makes a new long polling request. This cycle enables a better management of requests, since there is only a single request per session. Furthermore, the server can update the browser immediately with new information, without having to wait for the browser's next request. Because of its stability and usability, XHR long polling has become the standard approach for real-time applications and was implemented in various ways, including Forever iFrame, multipart XHR, JSONP long polling using script tags (for cross-domain, real-time support), and the common long-living XHR.

However, all these approaches were actually hacks using the HTTP and XHR protocols in a way they were not meant to be used. With the rapid development of modern browsers and the increased adoption of the new HTML5 specifications, a new protocol emerged for implementing real-time communication: the full duplex WebSockets.

In browsers that support the WebSockets protocol, the initial connection between the server and browser is made over HTTP and is called an HTTP handshake. Once the initial connection is made, the browser and server open a single ongoing communication channel over a TCP socket. Once the socket connection is established, it enables bidirectional communication between the browser and server. This enables both parties to send and retrieve messages over a single communication channel. This also helps to lower server load, decrease message latency, and unify PUSH communication using a standalone connection.

However, WebSockets still suffer from two major problems. First and foremost is browser compatibility. The WebSockets specification is fairly new, so older browsers don't support it, and though most modern browsers now implement the protocol, a large group of users are still using these older browsers. The second problem is HTTP proxies, firewalls, and hosting providers. Since WebSockets use a different communication protocol than HTTP, a lot of these intermediaries don't support it yet and block any socket communication. As it has always been with the Web, developers are left with a fragmentation problem, which can only be solved using an abstraction library that optimizes usability by switching between protocols according to the available resources. Fortunately, a popular library called Socket.io was already developed for this purpose, and it is freely available for the Node.js developer community.

### SOCKET.IO
Created in 2010 by JavaScript developer, Guillermo Rauch, Socket.io aimed to abstract Node.js' real-time application development. Since then, it has evolved dramatically, released in nine major versions before being broken in its latest version into two different modules: Engine.io and Socket.io.

Previous versions of Socket.io were criticized for being unstable, since they first tried to establish the most advanced connection mechanisms and then fallback to more primitive protocols. This caused serious issues with using Socket.io in production environments and posed a threat to the adoption of Socket.io as a real-time library. To solve this, the Socket.io team redesigned it and wrapped the core functionality in a base module called Engine.io.

The idea behind Engine.io was to create a more stable real-time module, which first opens a long-polling XHR communication and then tries to upgrade the connection to a WebSockets channel. The new version of Socket.io uses the Engine.io module and provides the developer with various features such as events, rooms, and automatic connection recovery, which you would otherwise implement by yourself.

When you include the Socket.io module, it provides you with two objects: a socket server object that is responsible for the server functionality and a socket client object that handles the browser's functionality.

#### Socket server object
The Socket.io server object is where it all begins. You start by requiring the Socket.io module, and then use it to create a new Socket.io server instance that will interact with socket clients. The server object supports both a standalone implementation and the ability to use it in conjunction with the Express framework. The server instance then exposes a set of methods that allow you to manage the Socket.io server operations. Once the server object is initialized, it will also be responsible for serving the socket client JavaScript file for the browser.

A simple implementation of the standalone Socket.io server will look as follows:

```
var io = require('socket.io')();
io.on('connection', function(socket){ /* ... */ });
io.listen(3000);
```

This will open a Socket.io over the 3000 port and serve the socket client file at the URL http://localhost:3000/socket.io/socket.io.js. Implementing the Socket.io server in conjunction with an Express application will be a bit different:

```
var app = require('express')();
var server = require('http').Server(app);
var io = require('socket.io')(server);
io.on('connection', function(socket){ /* ... */ });
server.listen(3000);
```

This time, you first use the http module of Node.js to create a server and wrap the Express application. The server object is then passed to the Socket.io module and serves both the Express application and the Socket.io server. Once the server is running, it will be available for socket clients to connect. A client trying to establish a connection with the Socket.io server will start by initiating the handshaking process.

####Socket.io handshaking
When a client wants to connect the Socket.io server, it will first send a handshake HTTP request. The server will then analyze the request to gather the necessary information for ongoing communication. It will then look for configuration middleware that is registered with the server and execute it before firing the connection event. When the client is successfully connected to the server, the connection event listener is executed, exposing a new socket instance.

Once the handshaking process is over, the client is connected to the server and all communication with it is handled through the socket instance object. For example, handling a client's disconnection event will be as follows:

```
var app = require('express')();
var server = require('http').Server(app);
var io = require('socket.io')(server);
io.on('connection', function(socket){
  socket.on('disconnect', function() {
    console.log('user has disconnected');
  });
});
server.listen(3000);
```

Notice how the socket.on() method adds an event handler to the disconnection event.
While the handshake mechanism is fully automatic, Socket.io does provide you with a way to intercept the handshake process using a configuration middleware.

#### The Socket.io configuration middleware
Although the Socket.io configuration middleware existed in previous versions, in the new version it is even simpler and allows you to manipulate socket communication before the handshake actually occurs. To create a configuration middleware, you will need to use the server's use() method, which is very similar to the Express application's use() method:

```
var app = require('express')();
var server = require('http').Server(app);
var io = require('socket.io')(server);

io.use(function(socket, next) {
  /* ... */

  next(null, true);
});

io.on('connection', function(socket){
  socket.on('disconnect', function() {
    console.log('user has disconnected');
  });
});

server.listen(3000);
```

As you can see, the io.use() method callback accepts two arguments: the socket object and a next callback. The socket object is the same socket object that will be used for the connection and it holds some connection properties. One important property is the socket.request property, which represents the handshake HTTP request. In the following sections, you will use the handshake request to incorporate the Passport session with the Socket.io connection.

The next argument is a callback method that accepts two arguments: an error object and Boolean value. The next callback tells Socket.io whether or not to proceed with the handshake process, so if you pass an error object or a false value to the next method, Socket.io will not initiate the socket connection.

#### The Socket.io client object
The Socket.io client object is responsible for the implementation of the browser socket communication with the Socket.io server. You start by including the Socket.io client JavaScript file, which is served by the Socket.io server. The Socket.io JavaScript file exposes an io() method that connects to the Socket.io server and creates the client socket object. A simple implementation of the socket client will be as follows:

```
<script src="/socket.io/socket.io.js"></script>

<script>
  var socket = io();
  socket.on('connect', function() {
      /* ... */
  });
</script>
```

Notice the default URL for the Socket.io client object. Although this can be altered, you can usually leave it like this and just include the file from the default Socket.io path. Another thing you should notice is that the io() method will automatically try to connect to the default base path when executed with no arguments; however, you can also pass a different server URL as an argument.

### Socket.io events
To handle the communication between the client and the server, Socket.io uses a structure that mimics the WebSockets protocol and fires events messages across the server and client objects. There are two types of events: system events, which indicate the socket connection status, and custom events, which you'll use to implement your business logic.

The system events on the socket server are as follows:

- **io.on('connection', ...)**: This is emitted when a new socket is connected
- **socket.on('message', ...)**: This is emitted when a message is sent using the socket.send() method
- **socket.on('disconnect', ...)**: This is emitted when the socket is disconnected

The system events on the client are as follows:

- **socket.io.on('open', ...)**: This is emitted when the socket client opens a connection with the server
- **socket.io.on('connect', ...)**: This is emitted when the socket client is connected to the server
- **socket.io.on('connect_timeout', ...)**: This is emitted when the socket client connection with the server is timed out
- **socket.io.on('connect_error', ...)**: This is emitted when the socket client fails to connect with the server
- **socket.io.on('reconnect_attempt', ...)**: This is emitted when the socket client tries to reconnect with the server
- **socket.io.on('reconnect', ...)**: This is emitted when the socket client is reconnected to the server
- **socket.io.on('reconnect_error', ...)**: This is emitted when the socket client fails to reconnect with the server
- **socket.io.on('reconnect_failed', ...)**: This is emitted when the socket client fails to reconnect with the server
- **socket.io.on('close', ...)**: This is emitted when the socket client closes the connection with the server

#### Handling events
While system events are helping us with connection management, the real magic of Socket.io relies on using custom events. In order to do so, Socket.io exposes two methods, both on the client and server objects. The first method is the on() method, which binds event handlers with events and the second method is the emit() method, which is used to fire events between the server and client objects.

An implementation of the on() method on the socket server is very simple:

```
var app = require('express')();
var server = require('http').Server(app);
var io = require('socket.io')(server);

io.on('connection', function(socket){
  socket.on('customEvent', function(customEventData) {
    /* ... */
  });
});

server.listen(3000);
```

In the preceding code, you bound an event listener to the customEvent event. The event handler is being called when the socket client object emits the customEvent event. Notice how the event handler accepts the customEventData argument that is passed to the event handler from the socket client object.

An implementation of the on() method on the socket client is also straightforward:

```
<script src="/socket.io/socket.io.js"></script>

<script>
  var socket = io();
  socket.on('customEvent', function(customEventData) {
    /* ... */
  });
</script>
```

This time the event handler is being called when the socket server emits the customEvent event that sends customEventData to the socket client event handler.

Once you set your event handlers, you can use the emit() method to send events from the socket server to the socket client and vice versa.

#### Emitting events
On the socket server, the emit() method is used to send events to a single socket client or a group of connected socket clients. The emit() method can be called from the connected socket object, which will send the event to a single socket client, as follows:

```
io.on('connection', function(socket){
  socket.emit('customEvent', customEventData);
});
```

The emit() method can also be called from the io object, which will send the event to all connected socket clients, as follows:

```
io.on('connection', function(socket){
  io.emit('customEvent', customEventData);
});
```

Another option is to send the event to all connected socket clients except from the sender using the broadcast property, as shown in the following lines of code:

```
io.on('connection', function(socket){
  socket.broadcast.emit('customEvent', customEventData);
});
```

On the socket client, things are much simpler. Since the socket client is only connected to the socket server, the emit() method will only send the event to the socket server:

```
var socket = io();
socket.emit('customEvent', customEventData);
```

Although these methods allow you to switch between personal and global events, they still lack the ability to send events to a group of connected socket clients. Socket.io offers two options to group sockets together: namespaces and rooms.

### Socket.io namespaces
In order to easily control socket management, Socket.io allow developers to split socket connections according to their purpose using namespaces. So instead of creating different socket servers for different connections, you can just use the same server to create different connection endpoints. This means that socket communication can be divided into groups, which will then be handled separately.

#### Socket.io server namespaces
To create a socket server namespace, you will need to use the socket server of() method that returns a socket namespace. Once you retain the socket namespace, you can just use it the same way you use the socket server object:

```
var app = require('express')();
var server = require('http').Server(app);
var io = require('socket.io')(server);

io.of('/someNamespace').on('connection', function(socket){
  socket.on('customEvent', function(customEventData) {
    /* ... */
  });
});

io.of('/someOtherNamespace').on('connection', function(socket){
  socket.on('customEvent', function(customEventData) {
    /* ... */
  });
});

server.listen(3000);
```

In fact, when you use the io object, Socket.io actually uses a default empty namespace as follows:

```
io.on('connection', function(socket){
/* ... */
});
The preceding lines of code are actually equivalent to this:

io.of('').on('connection', function(socket){
/* ... */
});
```

#### Socket.io client namespaces
On the socket client, the implementation is a little different:

```
<script src="/socket.io/socket.io.js"></script>

<script>
  var someSocket = io('/someNamespace');
  someSocket.on('customEvent', function(customEventData) {
    /* ... */
  });

  var someOtherSocket = io('/someOtherNamespace');
  someOtherSocket.on('customEvent', function(customEventData) {
    /* ... */
  });
</script>
```

As you can see, you can use multiple namespaces on the same application without much effort. However, once sockets are connected to different namespaces, you will not be able to send an event to all these namespaces at once. This means that namespaces are not very good for a more dynamic grouping logic. For this purpose, Socket.io offers a different feature called rooms.

### Socket.io rooms
Socket.io rooms allow you to partition connected sockets into different groups in a dynamic way. Connected sockets can join and leave rooms, and Socket.io provides you with a clean interface to manage rooms and emit events to the subset of sockets in a room. The rooms functionality is handled solely on the socket server but can easily be exposed to the socket client.

#### Joining and leaving rooms
Joining a room is handled using the socket join() method, while leaving a room is handled using the leave() method. So, a simple subscription mechanism can be implemented as follows:

```
io.on('connection', function(socket) {
    socket.on('join', function(roomData) {
        socket.join(roomData.roomName);
    })

    socket.on('leave', function(roomData) {
        socket.leave(roomData.roomName);
    })
});
```

Notice that the join() and leave() methods both take the room name as the first argument.

#### Emitting events to rooms
To emit events to all the sockets in a room, you will need to use the in() method. So, emitting an event to all socket clients who joined a room is quite simple and can be achieved with the help of the following code snippets:

```
io.on('connection', function(socket){
   io.in('someRoom').emit('customEvent', customEventData);
});
```

Another option is to send the event to all connected socket clients in a room except the sender by using the broadcast property and the to() method:

```
io.on('connection', function(socket){
   socket.broadcast.to('someRoom').emit('customEvent', customEventData);
});
```

learn more in https://socket.io.

### Configuración
To configure your Socket.io session to work in conjunction with your Express sessions, you have to find a way to share session information between Socket.io and Express. Since the Express session information is currently being stored in memory, Socket.io will not be able to access it properly. So, a better solution would be to store the session information in your MongoDB. Fortunately, there is node module named connect-mongo that allows you to store session information in a MongoDB instance almost seamlessly. To retrieve the Express session information, you will need some way to parse the signed session cookie information. For this purpose, you'll also install the cookie-parser module, which is used to parse the cookie header and populate the HTTP request object with cookies-related properties.

en **socketio.js**
First, you required the necessary dependencies, and then you used the io.use() configuration method to intercept the handshake process. In your configuration function, you used the Express cookie-parser module to parse the handshake request cookie and retrieve the Express sessionId. Then, you used the connect-mongo instance to retrieve the session information from the MongoDB storage. Once you retrieved the session object, you used the passport.initialize() and passport.session() middleware to populate the session's user object according to the session information. If a user is authenticated, the handshake middleware will call the next() callback and continue with the socket initialization; otherwise, it will use the next() callback in a way that informs Socket.io that a socket connection cannot be opened. This means that only authenticated users can open a socket communication with the server and prevent unauthorized connections to your Socket.io server.


should we create a constant for "your@mail.com" ? it's seems frequently used.


By "packed", do you mean all the assets are 'collated' into 1 file?


Don't be rude.  While I probably could have tested and pushed a fix, I
thought there might be a reason I hadn't considered for the way it was
done.  If you don't want my (admittedly meager) assistance, I will stop
providing it.

On Sat, Jan 16, 2016 at 8:14 PM, James Campos <notifications@github.com>
wrote:

> fixed - d2365a6
> <https://github.com/aeosynth/draft/commit/d2365a6018e917bee9d7e4d3dcce8b511b893dba>
>
> you should try understanding code, or at least making a change and seeing
> the effect
>
> —
> Reply to this email directly or view it on GitHub
> <https://github.com/aeosynth/draft/commit/f6211d331811abf41a99ba3117c802922c60b722#commitcomment-15493017>
> .
>


yes. otherwise you have to include this whole files:

```html
<script src="bower_components/jquery/dist/jquery.js"></script>
<script src="bower_components/jquery-bridget/jquery.bridget.js"></script>
<script src="bower_components/get-style-property/get-style-property.js"></script>
<script src="bower_components/get-size/get-size.js"></script>
<script src="bower_components/eventEmitter/EventEmitter.js"></script>
<script src="bower_components/eventie/eventie.js"></script>
<script src="bower_components/doc-ready/doc-ready.js"></script>
<script src="bower_components/matches-selector/matches-selector.js"></script>
<script src="bower_components/fizzy-ui-utils/utils.js"></script>
<script src="bower_components/outlayer/item.js"></script>
<script src="bower_components/outlayer/outlayer.js"></script>
<script src="bower_components/masonry/masonry.js"></script>
<script src="bower_components/imagesloaded/imagesloaded.js"></script>
<script src="bower_components/angular/angular.js"></script>
<script src="bower_components/angular-masonry/angular-masonry.js"></script>
```


you are right, I'll revert this commit.


You have a mistake on line 34. You have switched the quote and comma.


Has Go been influenced by [POSIX][]/Bash? It's not listed in the Wikipedia page, must be one of those languages.

```bash
if true; ! false; then echo BOOM; fi
```

I have never seen others can do like it until now. In Bash, I actually break each simple command/statement for their own line for readability.

[POSIX]: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_09_04_07


Why can't `basic_iterator` handle proxying the return value of post-increment just like it handles proxying the return value of `op*` for writable cursors?


The sharing issue with PKCS#11 is that you cannot share a module in a process with multiple consumers (e.g., engine_pkcs11 through a library dependency and direct usage of PKCS#11).

http://p11-glue.freedesktop.org/doc/p11-kit/sharing.html#sharing-problem


Might be a better place to do it :D


from what i know sqlite and mysql is case insensitive, and `LOWER()` is slow. I think, it's doesn't necessary.


This longest match logic is not reliable.. Need to improve.


This was further fixes for Refactoring #3 on our Trello board. I abstracted all of the generic, duplicated Servlet stuff into a single Abstract Servlet that all Servlet classes will extend. As you can see, I was able to delete A LOT of duplicated code in the subclasses as a result.


я индус


Line 17 is also missing a semicolon....


I’m neither, but I found both names in mixed use in our Help and picked the one that sounded most logical and edited the references to the tables in most object help pages.
So to me, a table showing Turnout entities for one a particular Turnout would be a Turnout Table proper.
Only later did I notice the tabs in the Preferences - Messages panel, which are created from beantable property names.

Some translations use plural, but for some objects it’s really hard (Logixs?).
I’ll certainly update any images in the help ASAP.

> Op 17 jan. 2016, om 23:56 heeft Bob Jacobsen <notifications@github.com> het volgende geschreven:
>
> If you want to change java/src/jmri/jmrit/beantable/BeanTableBundle.properties to make "table names as plural", please change all the help text and images to refer to that change too.
>
> (I'm neutral on whether this change is proper English. To me, since the unit of content of the table is e.g. a Turnout, it's a Turnout Table, not Turnouts Table. It's called a Phone Book, not a Phones Book; file system, not files system; Tax Tables, not Taxes Tables. But I'm not a native speaker.)
>
> —
> Reply to this email directly or view it on GitHub <https://github.com/JMRI/JMRI/commit/f262328a15cedd5cfe327d3a12c66dff8874be9b#commitcomment-15497206>.
>


HBIRE_vector_take2 (amirroth) - x86_64-MacOS-10.9-clang: OK (2038 of 2051 tests passed, 500 test warnings)

![Build Badge](http://img.shields.io/badge/build%20status-passing-green.svg) ![Test Badge](http://img.shields.io/badge/tests%20passed-99.37%25-yellow.svg)


No you work with Unicode data in string format not Unicode string objects.


Diese Funktion berücksichtigt nicht die einzelnen 32 Bit Werte sondern die ganzen 128 Bit. Daher wird sie für unsere Zwecke nicht das richtige Ergebnis liefern.


HBIRE_vector_take2 (amirroth) - x86_64-Linux-Ubuntu-14.04-gcc-4.8-UnitTestsCoverage-Debug: OK (957 of 957 tests passed, 0 test warnings)

![Build Badge](http://img.shields.io/badge/build%20status-passing-green.svg) ![Test Badge](http://img.shields.io/badge/tests%20passed-100.0%25-green.svg) ![Coverage Badge](http://img.shields.io/badge/coverage%20status-26.86%25-green.svg)


I'm a bit torn on this. It feels really odd to be releasing a new version of `dotenv` with no code changes. I also appear to have been mistaken on requiring a major version bump, Cargo does appear to successfully be figuring out the right syntex version to use (at the very least when my wife tried to use `diesel_codegen 0.4.1` with `dotenv_codegen 0.8.0` it didn't error like I expected)


you were in the chat when he was making those changes, so i assumed it was fine. i wouldnt just go and make a change without help from anyone


Wasn't able to add a description or meaningful title because I was leaving and just had to commit what I had done. But the only addition really is:

- Added an actual wave system, with support for scriptable waves.


I reverted it, good night and have a nice morning and day on the other side of our planet :)


@TomokoKuroki Logically speaking, you would want to recursively set your address/pointer to a specific value so that the client's native functionality cannot interfere with your code. Therefor, you thread a recursive routine so that the loop doesn't interfere with your core program's functionality.

Check out TyE's source [here](https://github.com/neetVeritas/tye-trainer/blob/master/src/BuildUp.cpp).


should this support py3 too? (print(...))


this is a comment at the top leve


Is it an O(1) access for sure ?


are you sure this is just a test?


Another stupid comment


Do we need a set here, i.e. do we expect more than one listener ? With a set, several questions come up:
1. We should document the fact that the listener should ensure that set membership works correctly by implementing hashCode()/equals().
2. The purgeTimeBucketsBefore() method should not take a long time since it is run with a lock held in the expiry task.
3. Do we need an unregister() method to remove a listener ?

All these go away if we limit it to just 1 listener.


That was my error. i use notepad for edition, i will download Atom IDE for edition next time @keithkfng


This branch seems better.

**You have to create the "RegisterChineseLocale" function in BossEncounter.lua file.**
On same model as English or french.

Maybe you will have to **add your language in GeminiLocale.lua file** in Libs folder.
This lib identify the language through the string returned by "Apollo.GetString(1)", near line 45.
So you will have to add an entry in ktLocales array.

```lua
local ktLocales = {
	[1] = "enUS",
	[2] = "deDE",
	[3] = "frFR",
	[4] = "koKR",
==>> [5]  = "xxYY" <== A chinese entry to add ?
}
```

To see the string returned , you can do in game:

```lua
/eval Print (Apollo.GetString(1))
 ```


what is this system for? testing purpose?


I have used 60 as default, people reported some lags, when restored to 100, its seems little better, as more ram is free... so maybe 70 or 80 will set better balance...
Its actually not save much power, just create lag when low ram...


@ghostoy Why is devtools checked? there is nowhere opening devtools in this case.


Sorry, I meant for #410 and #412


Hi Jonathan,

I am discussing with my partners the implications of your proposal. The big
problem is that this is a change that implies the change of all the
scripts, of the documentation and even of the release. There is a very
public demo scheduled for the 21 and 28 January and it is not prudent to do
last minute changes (which would also change their documentation and
presentation).

Curiously, believe it or not, we had already made a move in that direction,
but you couldn't know that because it was not published ;-)

The main opinion is that this is a nice to have. We all are very busy and
we are not keen on adding further work to our schedules. But we all also
acknowledge that the code would be more elegant (that is, less amateurish)
the way you propose it and, though these variables would be a bit more
hidden for guys who are not necessarily involved in informatics work, they
are not (that is still being discussed) too much hidden. It is true that if
users change them in all scripts and make an even slight error in filling
any of them they will have errors and a dysfunctional product. To compound
things, there are suggestions that go beyond yours (the MMM and
Moses-for-Mere-Mortals subdirectories should have more distinct names and
it would be appropriate that we organize the folder structure in a way that
eases further the installation).

Anyway, I have already tested your changes and they do work (as was
logically expected, but I try to never facilitate). You didn't touch one of
the scripts (transfer-training-to-another-location-0.09) and it was good
that you didn't because one of us, who normally makes very extensive tests
that none of us likes to make, is really keen on it not to be changed.

We have decided that we will discuss the matter further next Tuesday and
that we will not change anything before the January 28 demo. If we do
change things as you propose, we will acknowledge explicitly your work (in
fact, I have already done that in the changed scripts that I tested, but it
still is not visible in Github).

Is this not very clear situation acceptable to you (it will be a
provisional one)? ;-)

Why did you chose to look into Moses for Mere Mortals (just out of
curiosity)?

Greetings,

    João

On Sun, Jan 17, 2016 at 5:17 PM, Jonathan Chen <notifications@github.com>
wrote:

> Hi João,
>
> Thank you for your quick and thorough response!
>
> You are right; I had not considered the case where MMM and
> Moses-for-Mere-Mortals were not in the same folder. And I suppose the
> following is also easier to understand:
>
> mosesdir="$HOME/Desktop/Machine-Translation/MMM"
> MMMdir="$HOME/Desktop/Machine-Translation/Moses-for-Mere-Mortals"
>
> Adventurous users who would rather just change 1 path instead of 2 could
> implement something like $mtdir themselves.
>
> Please let me know if you want this change committed to my fork. Thank you
> for making Moses for Mere Mortals!
>
> Best,
> Jonathan
>
> —
> Reply to this email directly or view it on GitHub
> <https://github.com/ypeels/Moses-for-Mere-Mortals/commit/d075c05636015607f1c4fa2db56b86aacdd94f71#commitcomment-15495551>
> .
>

--
Um abraço,

   João


this is a comment on the first line


![Image of Yaktocat](http://yourslownewsday.com/wp-content/uploads/2016/01/20131031-Steve-Harvey1.jpg)


gsfrgtrsgrfgrfgrf


hfdhhdhh


hi


Good night. ;)


I guess this means `dokanctl.exe` has to be installed in this folder? Maybe the installer always does that, I'm just curious :)


Why the test aren't annotated?


so are atomics basically thread safe objects..?


Why does this class need to implement Component ?


For this patch only (remove posixAccount form samdb.py), Reviewed-by: Andrew Bartlett <abartlet@samba.org>


Does this work?  Try finding a topic in the console and doing `topic.sponsored_posts`?  I think you'll find an underscore on this line will help


Generalnie lepiej uzywac dla id i class nazw z malych liter oddzielonych np `-` lub `_`. Mozesz poczytac dlaczego tak w: `https://developer.mozilla.org/en/docs/Case_Sensitivity_in_class_and_id_Names`


This answers my previous question. Ignore! :)


HBIRE_vector_take2 (amirroth) - x86_64-Linux-Ubuntu-14.04-gcc-4.8-IntegrationCoverage-Debug: OK (1508 of 1508 tests passed, 0 test warnings)

![Build Badge](http://img.shields.io/badge/build%20status-passing-green.svg) ![Test Badge](http://img.shields.io/badge/tests%20passed-100.0%25-green.svg) ![Coverage Badge](http://img.shields.io/badge/coverage%20status-70.69%25-green.svg)


Hopefully evolved and not "butchered". I should have taken a better look at the coding before commit, thanks to dorimanx for the cleanup :)

https://github.com/UpInTheAir/SM-N920/commit/d27cd0389e6904bb84a1615e76ea6db71243b63d


This class isn't implementing a singleton, please review the theory and send this exercise again.


This is interesting, thanks for bringing it up. I have been keeping all three versions in sync, but maybe it's not a worthwhile thing to do?

It does seem weird to release versions with no changes, but it is also a bit weird to not have a clear mapping between `_codegen`/`_macros` versions and versions of the main crate. Should we consider them separate projects that happen to have dependencies on each other?

I honestly have no idea how to do this, and I'd like to get it right for 1.0, so any thoughts are welcome


Comment实体类


Any reason not to return super here? I'm thinking that even if cached children fails, fetching them one by onemay not. Sure, it'll be slower, but possibly better than brokenness? Or are you thinking the parent is totally broken?


Looks like this commit changed the wrong version number. ```bootstrap-sass``` appears to not yet be at version 4. ```laravel-elixir```, however, is.

@taylorotwell Can you revert this?


Sense of atomics: there is no middle ("in process") state: only "proceeded" or "not processed"


? You can still build and use Xaudio2.7 on newer WinOSes.


run `rake routes` and you'll probably see an extra route besides index you don't need and havn't implement for `sponosered_posts`  Check out the [routing guide](http://guides.rubyonrails.org/routing.html#crud-verbs-and-actions) for help.


One possible reason may be that we don't have `*.busname` units installed (`org.freedesktop.login1.busname` in this case).


HBIRE_vector_take2 (amirroth) - x86_64-Linux-Ubuntu-14.04-gcc-4.8: OK (2076 of 2089 tests passed, 503 test warnings)

![Build Badge](http://img.shields.io/badge/build%20status-passing-green.svg) ![Test Badge](http://img.shields.io/badge/tests%20passed-99.38%25-yellow.svg)


vff bfdbdfn ngd n


Your welcome mate. Thanks again for your initial implementation and also ideas I adapt to various commits. :)


missing slash
`distsystem-polyfills.js` -> `dist/system-polyfills.js`


Thanks!!!  This now runs on Raspbian


Should be also added that redistributing package with GAP also contributes to the ability to run it with future versions of GAP:
* we will be aware of some functionality used by the package (e.g. if we decide to rename or made it obsolete)
* we will run package regression tests and see if something is wrong
* more users may become interested in the package so might be able to help with its maintaining in the future


Can you please some snippets on how you declare your query and datatable? I can't replicate the issue.


wystarczy ze nadasz staly height paragrafowi ktory znajduje sie nad buttonami i mozesz tez im ustawic text-overflow bo bedzie wowczas w niektorych przypadkach ucinal tekst


cc @PedroTroller


fesetround? Wouldn't it be resetfound? Or am I just not getting what the feset part is?


@Yive We can't expect people to do the right thing, a lot of server owners have no clue about coding or what half of these things do.

My suggestions:
Lower max tick time from 1000 back to around 100.
Raise maximum collisions to 4 (sometimes people will be kicked for a stupid-sounding reason if it's 2).
Reduce item merges to 3 (4 looks absolutely ridiculous in the game, things fly towards each other).
Disable random light updates (unnecessary lag for some owners).
Raise activation range to 12 for both animals and monsters, plus raise misc to 6.

Up to you though.


One last suggestion to think about: ConcurrentSkipListSet may work better and also avoid re-populating and clearing the heap each time since it is thread-safe and maintains sorted order. Feel free to stay with the current version if you prefer it.


Yeah, basically, an operation which is atomic, guarantees no race
conditions to be possible in the middle of a single operation on the value.
std::atomic implements this for number of standard operations such as
assignment, comparison, and increment. It also provides some atomic
operations such as test-and-set which are often handy when implementing
some thread safe data structures.

In C++, std::atomic likely uses normal locks/mutexes internally when
applied to general purpose objects or non-standard types, but for some
standard numeric types it is likely to have template specialization that
compiles to more efficient processor-specific atomic operations, that can
be far faster than using locks.

On Sun, Jan 17, 2016 at 4:37 PM, Vitaly Novichkov <notifications@github.com>
wrote:

> Sense of atomics: there is no middle ("in process") state: only
> "proceeded" or "not processed"
>
> —
> Reply to this email directly or view it on GitHub
> <https://github.com/Wohlhabend-Networks/LunaDLL/commit/63d21865e9f844ec1b4d557a186ced173a8c6ed3#commitcomment-15497403>
> .
>


In hindsight, what went wrong was that we recreate the entry in the moduleLookup each time we run through this part of the loop. The result of this is that the module that was stored in the module lookup was never constructed, resolved, etc.


I understood that in the phrase "the statistical distribution those random variables follow, assuming in most cases that it is distributed normally", sorry.


We're still building against 2.7, this is just prep work for much later.


refs #5


[The success story of Gary Gygax.docx](https://github.com/Phillips-Christopher/Phillips_Christopher_Portfollio/files/93669/The.success.story.of.Gary.Gygax.docx)


This change breaks the install when using pip 1.5.6 (Ubuntu 15.04) - this version of pip doesn't seem to be compatible with the specified syntax but works fine when the change is reverted.


[Theodor Seuss Geisel.docx](https://github.com/Phillips-Christopher/Phillips_Christopher_Portfollio/files/93670/Theodor.Seuss.Geisel.docx)


Fixing #4


Great work


The new version in a later commit is ok -- I've also made an optional suggestion there.

The synchronization cost is sometimes unavoidable when multiple threads are involved. For example, TimeBucketAssigner.getTimeBucketFor() is called by all the put, getSync and getAsync methods and yet has 2 synchronized blocks.


Не проверял


Master shouldn't contain print(...
You need to create own logger class. And it should turn off logging for production


Why you need a lot of free lines?


A lot of lines


Master shouldn't contain commented code. Remove it.


remove commented code


a lot of space here, user 2 line brake between methods.


a lot of space


not informative comment


???How to reply? I am still confused about BossEncounter.lua file.   Dose BossEncounter.lua file means Kuralak.lua or ExperimentX89 and so on?


Issues mentioned in this commit (5879233b453b327cae9bc1cefdcb95e659c61532):

* [Issue #1](https://bugs.mtasa.com/view.php?id=1)


Issues mentioned in this commit (42fe3209fd25be41bbc90ee2e59f84fc7163087a):

* [Issue #3](https://bugs.mtasa.com/view.php?id=3)


Issues mentioned in this commit (a835c07305476659057a880f4024e93dc9eb9fed):

* [Issue #2](https://bugs.mtasa.com/view.php?id=2)


More descriptive parameter name like 'windowId' ? (also in TimeBucketAssigner)


master shouldn't  contain commented code.


Wouldn't background-size: 100%; or background-size: contain; be better?


I had a feeling someone would do that :)


Since you're touching this it might be helpful to elaborate on the "edit the fish_user_key_bindings" by pointing out the user may need to create an autoloaded function of that name in their ~/.config/fish/functions directory.


@keithkfng ;)


Hello, where can I clone this repo to my local account? can't find the "clone" button.


actually the goal was:
have authentification for user and another aithentification for sensitive admin settings,
but just did the admin part right now

display admin /icon  to show need to be authenticate to use this page, may not be obvious


ack


Good what is the status yet, can we push to the server?


Old icon is classic ;-;


ここが新たに追加した翻訳文です。確認をお願いします。


UpperCase on comment?

Very good commit!


you have compilation error ? I am pretty I do not but will double check


RonCheen


2 spaces


. kk


gfdgdf


@lucasart Please follow the discussion at fishcooking. And since I explicitly noticed the high hashsize in the testdescription and Joona approved them on the fly I guess it's OK.


I'm not sure this + sign is typo, did I do well?


@ngvtuan: Good work :+1: I fixed a typo here for you.


Tried to understand but with no luck, so I will just ask- does this fix issue #3305?


commited


won't show the change on my github desktop app though....


Oh, I guess it isn't needed, then.


No.. But it's a step in the right direction
On Jan 17, 2016 00:15, "UgisBrekis" <notifications@github.com> wrote:

> Tried to understand but with no luck, so I will just ask- does this fix
> issue #3305 <https://github.com/godotengine/godot/issues/3305>?
>
> —
> Reply to this email directly or view it on GitHub
> <https://github.com/godotengine/godot/commit/72fcb8a35beab251d01864bc67da3e3a8e75aed6#commitcomment-15493151>
> .
>


I left it as I was not sure of usage, but yes you may right to remove it


`(- -1 doc-width)` ?? :-)


(- -1 doc-width) ?? :-)


https://github.com/abo-abo/hydra/blob/master/hydra.el#L451-L454

` ¯\_(ツ)_/¯`


Okay.


Can you also add that value returned by reading doesn't have to match the actual behaviour?


@ace2nutzer, thanks for your investigations.

> This will run in single-precision .. if u don't care so much about precision things, the u can use half-precision by using: -mfpu=neon-fp16 ...this will work faster, also it'll use less RAM ;-)

Why not using half-precision then? Any downsides or side effects (besides of that it's recommended for audio/video-processing)?


I don't think it's a bad idea to add that. Question though, are we switching to ES6?


 iOS/Shou.TV/Resources/zh-Hant.lproj/Localizable.strings
"profile_text_logout" = "退出";      =>      "profile_text_logout" = "登出";


Drop the "in <a href..."; i.e., it should just be `...every time the shell starts.` People should know that their config.fish is sourced every time the shell starts. However, it might still be useful to add another sentence along these lines:

```
To minimize startup time do not put `abbr` commands in your
<a href="index.html#initialization">config.fish</a> file,
or any file sourced by it, unless you protect them by testing
whether your abbreviations are already set.
```

In fact, I can't help but wonder if we should document a pattern for this. Something like:

```
if not set -q my_fish_abbreviations
    abbr gco='git checkout'
    abbr abr='another abbreviation expansion'
    set -U my_fish_abbreviations 1
end
```


Shorten line.


数%ならよさそう


The color fix makes it so we don't have to use table.unpack when using a table for SetColor?


This line got erroneously removed in a prior commit (when i made the response json formation into a separate function call).  So there has been a bug where client subscriptions were not being removed from the manager after a timeout.  Now fixed!


Commit first change


This is also a simplification of the fix for Issue #1   There was no need to put the disconnect detection in a separate goroutine.

This is also the fix for Issue #4 because this causes the http handler to break out of the select on client disconnect.


Now testing for Issue #4


Sometimes it takes a very long time before you get a second chance :stuck_out_tongue_winking_eye:


**Note**: [Teaspoon][tsp], which runs the Javascript tests suites, requires CoffeeScript to be available. See https://github.com/gonzalo-bulnes/kata-emberjs-testing-on-rails/commit/e6b6a939360b38b20db82b63459bee375c214483.

  [tsp]: https://github.com/modeset/teaspoon


Nope, the shader from sf2dlib hadn't been updated so color wasn't working at all.


Oh, ok.


@MJ666 its set two lines above as masterConfig.escAndServoConfig.mincommand but then overwritten by the 0 value. There was no defines specifying which line operates. Perhaps we need to move it to have a conditional setting so if (feature(BRUSHED)) or similar the 0 else masterConfig.escAndServoConfig.mincommand?


Hype?