Shared posts
Is the Service Layer Obsolete?
How to create a distributed datastore in 10 minutes
In a typical system, you pull data in and out of somewhere that is safe, such as ZooKeeper or etcd. Then you operate on that data in places that are not necessarily safe, such as your application. And while etcd and ZooKeeper provide guarantees about the consistency of data in their possession, they cannot guarantee the consistency of broader state transitions and transactions that may involve other parts of your application. For that, we need another approach.
Changing the paradigm
Copycat is a framework that sidesteps the standard paradigm of building applications dependent on external systems for data consistency by allowing you to embed your application logic, written as a state machine, directly into Copycat, where consistency and fault tolerance are taken care of for you. The result is an ability to implement solutions to complex distributed coordination problems in a way that is relatively simple and concise and that encapsulates the logic and semantics of your application, without having to worry about reliability guarantees.
What kind of things can we build with Copycat? It’s up to you. From low level distributed primitives like locks, groups and maps to full blown distributed systems for scheduling, messaging, service discovery or data storage, nearly anything is possible.
From zero to distributed datastore
A good place to start with Copycat is to build something with it, so let’s create a distributed key-value datastore. We’re not aiming to create just any datastore though, we want something with strong consistency guarantees, fault-tolerance in the case of network partitions, durability in the case of node failure, and notifications for data changes – something along the lines of etcd. Is it really possible to build an etcd clone in 10 minutes? Well, no, but we can amazingly close, building a datastore with the same basic features, and more importantly, the same reliability guarantees, in that amount of time.
The state machine
The first step in building our datastore is to define a state machine to contain our datastore’s state and logic. Since our datastore is storing key-value pairs, we’ll encapsulate data in memory using a simple HashMap
. Seriously, a HashMap? What about thread-safety? What about durability? Copycat will take care of these things for us as we’ll learn more about later. But first, let’s define our state machine:
public class KeyValueStore extends StateMachine { private Map<Object, Object> storage = new HashMap<>(); }
In order to operate on our state machine, we’ll need to declare some operations. Copycat supports two types of operations: commands which are intended for writes and queries which are intended reads. Let’s start by defining some of the basic etcd-style operations: put
, get
and delete
:
public class Put implements Command<Object> { public Object key; public Object value; public Put(Object key, Object value) { this.key = key; this.value = value; } } public class Get implements Query<Object> { public Object key; public Get(Object key) { this.key = key; } } public class Delete implements Command<Object> { public Object key; public Delete(Object key) { this.key = key; } }
With our operations defined, let’s implement handling for them inside of our StateMachine
:
public class KeyValueStore extends StateMachine { private Map<Object, Commit> storage = new HashMap<>(); public Object put(Commit<Put> commit) { Commit<Put> put = storage.put(commit.operation().key, commit); return put == null ? null : put.operation().value; } public Object get(Commit<Get> commit) { try { Commit<Put> put = map.get(commit.operation().key); return put == null ? null : put.operation().value; } finally { commit.release(); } } public Object delete(Commit<Delete> commit) { Commit<Put> put = null; try { put = storage.remove(commit.operation().key); return put == null ? null : put.operation().value; } finally { if (put != null) put.release(); commit.release(); } } }
As you can see, the put
, get
and delete
implementations handle Commit
objects that contain operations submitted to the state machine. Operations are executed on a single thread, so thread-safety is a non-issue, and after being handled, operations return a result that reflects the internal state of our machine.
Aside from the state machine’s storage, Copycat also stores an internal log of every command processed by the state machine along with its result, which it uses for failure handling and other purposes. Periodic compaction is performed on the log in order to remove commits that are no longer needed. To help Copycat know when it’s safe to remove a commit from its log, the state machine should release
commits that do not contribute to the state of the machine. A Put
operation, for example, is not released until after a Delete
operation is received for the same key. A Get
operation, on the other hand, is released right away since it does not contribute to the state of the machine.
With this, our basic key-value store is now implemented! We’ll add some more advanced operations later, but now let’s get ready to try it out.
Creating the server
To manage our state machine we’ll need to build a CopycatServer
instance. The server must be initialized with an address to listen for communication on:
Address address = new Address("123.456.789.0", 5000); CopycatServer.Builder builder = CopycatServer.builder(address);
We’ll configure the server to use our state machine:
builder.withStateMachine(KeyValueStore::new);
And configure a Transport
for the server to use when communicating with clients other servers in a cluster:
builder.withTransport(NettyTransport.builder() .withThreads(4) .build());
We’ll configure a Storage
implementation for our state machine’s log, using on disk storage in this case:
builder.withStorage(Storage.builder() .withDirectory(new File("logs")) .withStorageLevel(StorageLevel.DISK) .build());
And finally we’ll create the server:
CopycatServer server = builder.build();
Bootstrapping a cluster
Once a server has been built, we can use it to bootstrap a new cluster:
server.bootstrap().thenAccept(srvr -> System.out.println(srvr + " has bootstrapped a cluster"));
At this point our state machine is up and running, but let’s join some additional servers to the cluster:
Address clusterAddress = new Address("123.456.789.0", 5000); server.join(clusterAddress).thenAccept(srvr -> System.out.println(srvr + " has joined the cluster"));
And just like that, we have created a clustered key-value store!
Performing operations
In order to submit operations to our datastore, we’ll need to create a CopycatClient
. We’ll be sure to configure the same Transport
for our client that we configured for our servers:
CopycatClient client = CopycatClient.builder() .withTransport(NettyTransport.builder() .withThreads(2) .build()) .build();
Then we’ll point our client to any of the servers in our cluster, and connect
:
Address clusterAddress = new Address("123.456.789.0", 5000); client.connect(clusterAddress).join();
With our client connected, let’s submit a put
operation:
CompletableFuture<Object> future = client.submit(new Put("foo", "Hello world!")); Object result = future.get();
We can also submit get
and delete
operations in the same way as a put
:
client.submit(new Get("foo")).thenAccept(result -> System.out.println("foo is: " + result)); client.submit(new Delete("foo")).thenRun(() -> System.out.println("foo has been deleted"));
From here we can wrap the client in a CLI or REST API to allow other types of access, but we’ll leave that as an exercise for another time.
Achieving consistency
Now that we have an initial system up and running, let’s take a step back to discuss what’s going on under the covers. Remember at the outset when we stated that it’s not enough to build our own key-value store, we want it to be fully replicated, durable, strongly consistent, and able to handle failures. How do we do all that? It turns out, we already have.
Copycat utilizes a sophisticated implementation of the Raft consensus algorithm to ensure that every operation against your state machine is replicated to every member of the cluster, in a safe way. To accomplish this, each server in the cluster maintains a separate copy of the state machine along with a log of all operations that have been performed on the state machine and their results. Logs can be durably stored according to the configured StorageLevel
and are used to restore the state of a machine in the event of a failure.
In order to achieve strong consistency, Copycat utilizes a majority quorum to ensure that write operations are approved by a majority of nodes in the cluster before they take effect. In the event of a network partition or system failure where a quorum can no longer be achieved, Copycat will cease to process write operations in order to prevent data inconsistency from occurring.
Copycat clusters elect a leader to serve as the focal point for processing operations. When a command is submitted by a client to a server, it’s forwarded to the leader which in turn sends the command to the rest of the cluster. Each server then applies the command to its state machine, appends the result to its log, and returns a response to the leader. Once the leader has received a response from a majority of the cluster (including itself), it applies the command to its own state machine and log then sends a response back to the client.
Copycat supports configurable consistency levels per query operation. When a query is submitted by a client to a server, it can either be forwarded to the leader if linearizable consistency is desired, or it can be responded to by any server if sequential consistency is sufficient.
Achieving fault-tolerance
Copycat utilizes heartbeats and timeouts to assert healthy connectivity between servers. If a leader fails to issue a heartbeat within the configured timeout period, the remaining members of the cluster will elect a new leader to coordinate the processing of operations. Likewise, if a follower fails to respond to a heartbeat, that server may be removed from the cluster.
Since Copycat requires a majority quorum in order to maintain consistency and remain available, Copycat supports passive and reserve servers which can be made to replace active servers in the event of a failure. When a new server joins the cluster, the leader streams its log to the server which in turn applies the logged operations to its state machine. Once the server is fully caught up, the leader will promote the new server to an active member of the cluster.
Now that we understand a little about how Copycat turns our basic state machine into a robust, distributed key-value store, let’s turn back to our implementation and add a few more advanced capabilities.
Time to live
One nice feature that etcd supports is time-to-live for keys. This allows keys to be auto-deleted after a certain time period. Let’s add TTL support to our datastore. We’ll start by defining a new PutWithTtl
command:
public class PutWithTtl implements Command<Object> { public Object key; public Object value; public long ttl; public PutWithTtl(Object key, Object value, long ttl) { this.key = key; this.value = value; this.ttl = ttl; } @Override public CompactionMode compaction() { return CompactionMode.EXPIRING; } }
Since a PutWithTtl
command should result in the removal of state after some amount of time, we need to indicate this to Copycat so that it can properly compact these commits from the log. We do this by providing a compaction()
implementation that returns CompactionMode.EXPIRING
.
Next, we’ll need to implement handling of the PutWithTtl
command inside of our state machine:
public Object putWithTtl(Commit<PutWithTtl> commit) { Object result = storage.put(commit.operation().key, commit); executor.schedule(Duration.ofMillis(commit.operation().ttl), () -> { storage.remove(commit.operation().key); commit.release(); }); return result; }
Here we schedule a future action to execute after the TTL has been exceeded, which will remove the commit from storage and release it, similar to our delete implementation from earlier. We use the state machine’s internal executor to schedule the entry removal since this ensures we won’t encounter any thread-safety issues inside of our state machine.
Watch what happens
With TTL implemented, let’s add one final feature: watchers. Watchers in etcd and in ZooKeeper allow clients to receive a notification when a key has been accessed. This an important feature for implementing a variety of coordination patterns, but it typically carries various caveats including rigid semantics and lesser reliability guarantees.
Copycat, on the other hand, provides a session eventing capability that allows arbitrary data to be published directly to clients from anywhere inside a state machine. This flexibility enables us to easily model complex distributed primitives such as groups, leader election, and messaging where server-side information is published to clients in an efficient and semantically appropriate manner. Session events are guaranteed not to be lost in the case of a server failure and are always delivered in sequential order.
To leverage session events for our datastore, we’ll start by defining a new Listen
command that will indicate a client’s interest in receiving events from our state machine:
public class Listen implements Command<Object> { }
Next, we’ll enhance our KeyValueStore
implementation to handle the Listen
command:
public class KeyValueStore extends StateMachine { private Map<Object, Commit> storage = new HashMap<>(); private Set<Commit> listeners = new HashSet<>(); public void listen(Commit<Listen> commit) { listeners.add(commit); }
The listen
method simply stores the client submitted commit, which we’ll later use to publish events back to the client. We’ll need to define an EntryEvent
type that will encapsulate our event data:
public class EntryEvent<K, V> implements Serializable { public Object key; public Object oldValue; public Object newValue; public EntryEvent(Object key, Object oldValue, Object newValue) { this.key = key; this.oldValue = oldValue; this.newValue = newValue; } public String toString() { return String.format("EntryEvent [key=%s, oldValue=%s, newValue=%s]", key, oldValue, newValue); } }
And finally we’ll enhance our KeyValueStore
to publish EntryEvent
s from within our existing command handlers using the client session associated with any Listen
commands:
private void publish(String event, Object key, Object oldValue, Object newValue) { listeners.forEach(commit -> { commit.session().publish(event, new EntryEvent(key, oldValue, newValue)); }); } public Object put(Commit<Put> commit) { Commit<Put> put = storage.put(commit.operation().key, commit); Object oldValue = put == null ? null : put.operation().value; publish("put", commit.operation().key, oldValue, commit.operation().value); return oldValue; } public Object putWithTtl(Commit<PutWithTtl> commit) { Object result = storage.put(commit.operation().key, commit); executor.schedule(Duration.ofMillis(commit.operation().ttl), () -> { Commit<PutWithTtl> put = storage.remove(commit.operation().key); Object oldValue = put == null ? null : put.operation().value; publish("expire", commit.operation().key, oldValue, null); commit.release(); }); return result; } public Object delete(Commit<Delete> commit) { Commit<Put> put = null; try { put = storage.remove(commit.operation().key); Object oldValue = put == null ? null : put.operation().value; publish("delete", commit.operation().key, oldValue, null); return oldValue; } finally { if (put != null) put.release(); commit.release(); } }
On the client side, we’ll publish a Listen
command to indicate our interest in receiving events:
client.submit(new Listen()).thenRun(() -> LOG.info("Now listening for events")).join();
Then we can register event listeners for specific events:
client.onEvent("put", (EntryEvent event) -> System.out.println("Put: " + event)); client.onEvent("delete", (EntryEvent event) -> System.out.println("Delete: " + event)); client.onEvent("expire", (EntryEvent event) -> System.out.println("Expire: " + event));
Now, when state changes occur within our datastore, clients will be notified.
Wrapup
Well, that’s it. Our 10 minutes are up and with the help of Copycat we’ve created a production-ready, strongly consistent clustered key-value store from scratch. We also learned a bit about consistency and fault tolerance in distributed systems, and, hopefully, now we’re ready to create something else with our new knowledge.
The goal of Copycat and it’s sister project Atomix isn’t to build a clone of any specific technology such as etcd, as achievable as that may now seem. The goal is to empower users to build systems to suit their own needs.
Copycat allows us to build complex systems faster, safer, and more easily than before. So, now that you’ve seen what it can do, what will you build?
This post was originally published on Jonathan Halterman’s personal website.
The post How to create a distributed datastore in 10 minutes appeared first on JAXenter.
Selenium Headless Browser Testing
5 ways to find positive things in code reviews
Telling someone that their code is not good enough may trigger undesired animosity between the defendant and the plaintiff, which is why developers have mixed feelings about code reviews (no matter if they are the ones reviewing or being reviewed). According to Atlassian, code reviews make for better estimates, they enable time off and newer engineers. However, one cannot ignore one of the biggest downsides of code reviews —they make developers vulnerable.
So the question remains: how do you tell a developer that their code is not so good without hurting their ego? We found the answer to this question on Stack Exchange and Quora.
10 lines of code = 10 issues.
500 lines of code = “looks fine.”
Code reviews.
— I Am Devloper (@iamdevloper) November 5, 2013
Criticize the code, NOT the author
One popular opinion is to criticize the code and not the author. It’s better not to use the words “you” or “I” —instead, use “the” or “a” to talk about code and keep it impersonal. Again, a person whose code is being reviewed is vulnerable and talking about “their” code instead of “the” code will just make matters worse.
It’s the tone that makes the music
If you are talking to them in person, you should know that your tone (and body language, for that matter) matters. You don’t want to accidentally dismiss their skills and you surely don’t want to act superior, no matter the type of mistake they did. As we mentioned earlier, code reviews are (obviously) all about finding the flaws but they should not transform into a witch hunt. So tone down your voice and attitude and present strong arguments to make them understand why the quality of their code is poor.
Write down the rules for passing a code review
One of the people who commented on this matter opined that code review will not be like walking on eggshells if there are clear rules for passing a code review. If the developer does not agree with your comments, all you need to do is show them the rules. Although it’s not ideal to hide behind a list of dos and don’ts, the only thing you will be guilty of is checking if the rules have been followed.
Allow them to get even
It’s not always possible to stop them from hating you if you criticize their code but what you can do is give them the chance to get even. This is not exactly healthy but if you allow developers to review each other’s code (but ask specific questions, moderate this whole experiment), they might learn something from each other. One thing is sure — they will bend over backwards to point out others’ flaws but if you convince them to say exactly how they would improve the code, this attempt will turn into a team exercise and not a vengeful, adversarial one.
Be proactive — give constructive criticism
There are ways to communicate bad news professionally but chances are that the person who reviews developers’ code will not use them. What the reviewer needs to do is offer answers to the following questions: What’s wrong with the code? How can the developer make it better?
Make sure they know that your door is always open if they have further questions or comments and offer them the option to review the code privately.
If this doesn’t work, use biometrics to measure code quality. Sebastian C Müller and Thomas Fritz from the University of Zurich, Switzerland acknowledged that relying on code review is “a common industrial practice to identify code quality concerns,” but warned that this method has two major flaws: it is costly and it only takes place after a code change is already completed.
The researchers used Ward Cunningham’s quote “every minute spent on not-quite-right code counts as interest on that debt” to emphasize that “delaying software quality concerns [defects or poor understandability of the code] increases the cost of fixing them.” Müller and Fritz’s goal is to use biometric sensing to overcome these disadvantages and lower the development cost by identifying code quality concerns online while the developer is still working on the code.
The results show that biometrics helped to automatically detect 50% of the bugs found in code reviews and outperformed traditional metrics in predicting all quality concerns found in code reviews.
Although the paper shows the benefits of using biometrics to measure code quality, it also notes the privacy concerns. The researchers claim that “more research is needed to investigate a feasible solution.”
The post 5 ways to find positive things in code reviews appeared first on JAXenter.
“Eclipse IDE still has bright days ahead”
We talked to Mikaël Barbero, Senior Platform Developer, about what Eclipse means to him, what will happen in the future and we turn back time to the moment he joined the Eclipse Foundation.
JAXenter: What are your duties and responsibilities within the Eclipse Foundation?
Mikaël Barbero: Since its inception, the Eclipse Foundation has never participated in the code development of the hosted projects. That situation recently changed. The board of directors noticed that contributions to the core Eclipse projects (Equinox, Eclipse Core / UI, JDT) were dangerously dropping year after year.
Two decisions were taken to revive these fundamental projects. The first one was to set up the Friend of Eclipse Enhancement Program [1]: donations made to the Eclipse Foundation are now used to fund people to fix outstanding bugs as identified by the community. The second one was to hire an experienced developer to technically supervise this program and to make actual improvements! This is where I stand. My role is to continuously contribute to the core Eclipse projects by fixing bugs and adding features expected by the end users but less interesting in the developer community’s eyes.
JAXenter: When did you join the Eclipse Foundation and why?
Mikaël Barbero: I joined the Eclipse Foundation in February 2015. But I jumped on the Eclipse train long before that! I have been developing Java projects with Eclipse for 10 years and I have been a committer on several projects for seven years. I really love this community, made of smart people that I’ve got to know and work with. I even became friends with some of them.
My role is to continuously contribute to the core Eclipse projects.
So when I heard about an open position at the Eclipse Foundation, I did not hesitate long before submitting my résumé and it was a great honor to become part of the team. My main motive to join the Foundation was to give back. I’ve benefitted from the help of the Foundation and the community for many years now, and it is very rewarding to be able to develop and nurture the platform, the ecosystem and the community.
JAXenter: Which project(s) do you like most?
Mikaël Barbero: Even if I’m less and less involved in the Modeling projects, I started my Eclipse journey with some of them. They obviously still have a special place in my mind; especially the Eclipse Modeling Framework (EMF), a very brilliant piece of software engineering. In my humble opinion, it has been a real force multiplier for Eclipse. Besides EMF, my favorite projects are, of course, the ones from the core platform stack (i.e., Equinox, SWT, RCP and IDE Platform, and JDT).
My main motive to join the Foundation was to give back.
JAXenter: What does the future of Eclipse (and the Foundation) look like?
Mikaël Barbero: I want Eclipse and the Foundation to be disruptive again. In the early 2000s, the Eclipse Project and the Eclipse Foundation created the new standard of IDE, providing a open source common portable software development platform. They did it while implementing a framework to allow individuals and organizations to collaborate on commercially-friendly open source software.
All this was quite new at that time, and it’s impressive how ubiquitous this kind of framework is nowadays. The Foundation did its job very well for more than 10 years, but as Mike (Ed. Mike Milinkovich, the Executive Director of the Foundation) once told me, “you can do something very well during 10 years, but after 10 years it may not be right thing anymore”.
The disruption might as well be the working groups that the Foundation created in the past few years. The working groups gather people with common interests (like Eclipse IoT about the IoT (sic), or Polarsys about the system engineering and the embedded systems) and the Foundation is here to help them collaborate.
JAXenter: Finally — Eclipse Neon. What is your favorite feature?
Mikaël Barbero: I’m not a web developer, but I am really enthusiastic about the rebirth of the JavaScript and Web Development Tooling in Eclipse. It has been neglected for so many years to a point that it was mostly irrelevant to any developer who wanted to get his work done. The renewed interest that the community has provided to create a modern and performant Web Development Tooling is very encouraging and is the proof, if any was needed, that the Eclipse IDE still has bright days ahead.
Thank you very much!
[1] If you want to know more about this program, I recently wrote a blog post about it.
Check out our ‘Foundation Talk’ series
The post “Eclipse IDE still has bright days ahead” appeared first on JAXenter.
Hillary diz que hackers russos roubaram informações de seu partido
Muslim woman thrown out of Trump rally
EduEngraçado como a opnião geral faz parecer que essa é uma situação fácil como escolher um lado. Na realidade tudo isso vai piorar muito antes de mellhorar.
'You touched my nurse': Russian doctor hits & kills patient in hospital (VIDEO)
EduMeu, que vídeo perturbador.
Read Full Article at RT.com
Steve Wozniak "Steve Jobs Played No Role In My Designs For the Apple I & II"
EduNo shit.
Read more of this story at Slashdot.
Google Is Dropping Its Google+ Requirement Across All Products Including YouTube
EduFailure
Read more of this story at Slashdot.
A Nest Of Vipers, The Fifth Episode Of TellTale's Game Of Thrones, Is Now Available
Edu...and it sucks.
The fifth installment in TellTale's Game of Thrones adventure game adaptation has arrived. If you've been playing through each episode as they're released, now is the time for you to jump back into the game. As for those of you who are contemplating joining in for the first time, know that you have more content to play through all at once than those who started before you.
When you download Game of Thrones from the Play Store, it comes with the first episode included.
Read MoreA Nest Of Vipers, The Fifth Episode Of TellTale's Game Of Thrones, Is Now Available was written by the awesome team at Android Police.
Police truncheon texts the officer’s mother when it is...
EduEssencial
Police truncheon texts the officer’s mother when it is used
Russian artist Dmitry Morozov has designed a prototype truncheon that sends a text message to the police officer’s mother every time it is used, in an attempt to prevent police brutality.
The Antenna baton is equipped with a network-connected module that sends the words “Mom, I hit a man” as an SMS message to the police officer’s mother whenever it is used.
Great Job, Internet!: This supercut of bad special effects is a reminder of how far we’ve come
EduOs anos 90 foram lindos.
The strange truth about CGI special effects is that they always look bad and they’re always getting better. Because while the dinos in Jurassic World or the car crashes in Terminator: Genisys are recognizably unreal, they’re miles ahead of the footage showcased in this supercut of bad special effects. And it’s not just B-movies like Mega Shark Vs. Giant Octopus that look ridiculous, big blockbusters from a decade or two ago like Air Force One, Peter Jackson’s King Kong, and Die Another Day feature the kind of special effects you’d now expect to see on any halfway decent YouTube channel. So while we’re rightfully complaining about the fake quality of our contemporary CGI, let’s also take a moment to acknowledge just how far we’ve come.
RT @johannicks: sras e srs aqui temos o ápice dos comentários http://t.co/yAAbtfGmJT
EduOs caras só tem um tema. haha
|
Here’s What Batman Would Look Like as a Viking, Iron Man, and More!
The LEGO Batman Movie will reportedly acknowledge every era of the Caped Crusader on-screen—but before we take that stroll down memory lane in 2017, let’s turn our eyes to the Batmen that could have existed. 3D character artist Caleb Nefzen dreamed up what Batman would look like as a fearsome Viking warrior (above); on deviantART, DenisM79 reimagines the Dark Knight as a greaser punk; and even more artists have envisioned Batman in every era.
Meet Rockabilly Batman, with bonus hot rod Batmobile! (by DenisM79):
Batman of the Ottoman Empire (by Eren Arik):
The Iron Bat (by Boss Logic):
Underworld Batman (by fear-sAs):
“I AM THE NIGHT. I AM EVERY NIGHT. I AM LITERALLY EVERY ERA YOU CAN THINK OF.”
Check out more illustrations, including Revolutionary Batman (what’s up with that sword?), Steampunk Batman, and Nuclear War Batman.
This article was originally published December 8, 2014.
JSONx is an IBM standard format to represent JSON as XML
EduMelhor gif.
by keiran_s
Usuários mais assíduos do Facebook devem ter notado ontem um comportamento muito estranho na maior rede social do mundo. Na aba de notificações, em vez do tradicional botão "Marcar todas como lidas", muita gente viu mensagens no mínimo estranhas como "sai feminazi,...
EduImpressionante como as circunstâncias forçam as empresas grandes a engessarem os processos.
Man learns never to mess with disabled parking in Brazil (VIDEO)
Read Full Article at RT.com
The US government wants to speed up deployment of vehicle-to-vehicle communication
EduTô cansado de ter minhas idéias copiadas, gente.
Vehicle-to-vehicle (V2V) communication is one of the next big sea changes to hit the auto industry — within a few years, every new car on the road will be wirelessly talking with every other new car on the road, delivering position and speed information that can help prevent accidents. NHTSA had already committed to delivering a set of proposed rules for V2V by next year, but USDOT secretary Anthony Foxx doesn't think that's fast enough: he's asked the agency to "accelerate the timetable" in comments made this week. Additionally, he says that he's gearing up for "rapid testing" in concert with the FCC to make sure that there are no radio interference issues with V2V systems. (Various industry groups have been concerned that efforts to e...
Biologists Create Self-Healing Concrete
EduEvidentemente essa matéria não precisa ser lida além do título.
Read more of this story at Slashdot.
The Solution To Argentina's Banking Problems Is Go Cashless
EduOlha só que curioso esse mundo.
Read more of this story at Slashdot.
'OK, Google' Everywhere Is Broken On The Galaxy S6 And S6 Edge, And Nobody Seems To Know Why
Have a Galaxy S6 or Galaxy S6 Edge? Great! Want to use OK Google's hotword functionality from anywhere but the Google app or the Google Now launcher? Not great!
You see, for the past month or so since the S6 launched, there's been a slight issue with OK Google Everywhere on the Galaxy S6. Specifically, it just stops working completely. All the options except "From the Google app" disappear, voice model training goes away, and you can only use the 'OK, Google' hotword from the Google app or the Google Now Launcher (which is, essentially, the Google app).
Read More'OK, Google' Everywhere Is Broken On The Galaxy S6 And S6 Edge, And Nobody Seems To Know Why was written by the awesome team at Android Police.
The center of our galaxy might be full of dying vampire stars
Edu[/f] Como eu sempre supus
A special space telescope has helped scientists gain a much better grasp on what's happening at the crowded center of our galaxy, according to findings published in Nature yesterday.
Earth is stuck near the edge of the Milky Way, tucked in a quiet spot just off of one of the galaxy's spiral arms. The center of our galaxy, on the other hand, is an extremely busy place. If we're in the suburbs, the galactic center is Times Square; it's packed full of stars that are dead or dying, giant gas clouds, and of course, one supermassive black hole. And while astronomers learn a lot about our galaxy by looking at its cosmic doppelgängers, there's still much to be gained by studying the busiest parts of our own.
If we're in the suburbs, the...
‘Batman v Superman: Dawn of Justice’ trailer leaks
France wants to fight terrorism by spying on everyone
French lawmakers have spent the past four days debating a controversial anti-terrorism bill that, if passed, would dramatically expand the government's surveillance powers. The law's backers describe it as a necessary measure to thwart terrorist attacks, and it has strong support on both sides of the aisle. But the bill has drawn sharp criticism from French internet companies over fears that it could harm business, and from privacy advocates who say it would severely curtail civil liberties.
The proposed law, introduced in Parliament on Monday, would allow the government to monitor emails and phone calls of suspected terrorists and their contacts, without seeking authorization from a judge. Telecommunications and internet companies...
How The Facebook Bubble Is Driving Online Startups Into The Arms Of Offline Advertising
Edu[f] "...our eight-figure annual marketing budget elsewhere..." Levando em consideração os decimais, vírgulas e pontos de separação de milhar?
RT @diogobatalha: Tiririca. Soletre para mim o alfabeto. http://t.co/8QmKitxreB
Edu[f]
|
I made an NES emulator - here's what I learned
O retorno do Largato de Pinto! - Melhores do Mundo
Pois é, nerdaiada maldita… .depois de vários anos a Marvel trouxe de volta às suias capas o terrível Largato de Pinto!!! (só leitores velhacos lembrarão dele)
Com a nova-nova-nova iniciativa de remodelar personagens, grupos e trazer novas equipes criativas, a Marvel revelou mais dois personagens da capa misteriosa dos Vingadores que será distribuído no Free Comic Book Day lá na gringa, e juntando-se à Thor e Miss Marvel, temos agora o Visão e o Nova:
Sobre os heróis que faltam, a galera na gringa tá apostando que o cara de asas seja o Capitão Falcão, o cara voador ao lado dele seja o Homem de Ferro Superior e no centro da capa teríamos a grande novidade, com Miles Morales fazendo parte da equipe principal dos Vingadores após a quizumba toda de Secret Wars passar.
O que eu acho? Caras, obóvio que os 3 personagens que faltam na verdade são só dois, o Largato de pinto clássico e o Largato de Pinto Voador!!!
Agora, me diz uma coisa Marvel, pra que diabos ficar com essas pataquadas de ALL-NEW, ALL-DIFFERENT, ALL-MY-CACETE-ALADO pra dizer a mesma coisa de sempre de que “agora é tudo novo”, “de um jeito que vocês nunca viram”, “mudanças radicais e profundas”… ah, numa boa:
Scan Reveals This Buddha Statue Has A Mummy Inside
Edu[f] Beleza. Tão mandando bem no auto-controle esses budistas.