#calaya

New Post has been published on http://omgnewsy.com/heartwarming-moment-a-gorilla-cradles-kisses-moke-her-newborn-video-images/

Heartwarming Moment A Gorilla Cradles, Kisses Moke Her Newborn (Video/Images)

Astonishing photographs and video from the National Zoo show the first interaction between a mother gorilla and her newborn baby.

First-time mother Calaya gave birth to her son, Moke – pronounced mo-KEY – a western lowland gorilla, on Sunday at the Smithsonian National Zoo & Conservation Biology Institute in Washington, D.C.

The astonishing gorilla birth was the first in nine years to take place at the zoo. Zoo officials captured the special moment, which was shared to the zoo’s website as well as social media on Monday morning.

‘We’re thrilled to share western lowland gorilla Calaya gave birth to a male at 6:25 p.m. 4/15. His name, Moke, means “junior” or “little one” in the Lingala language,’ the National Zoo wrote to their Twitter page.

The mama gorilla seen holding the baby close before laying him down to rest inside the enclosure

‘Keepers report that Calaya has been caring for her infant & are optimistic he will thrive. #GorillaStory’.

Moke the adorable baby gorilla was bred last summer by 15-year-old mom Calaya and 26-year-old father Baraka.

The extremely caring mother is seen in video footage holding onto her baby while keeping a locked gaze on him.

Above shows baby Moke’s content face as he relaxes inside the enclosure at the Great Ape House in the Smithsonian National Zoo

She then gently kisses Moke several times while admiring him and holding the baby close before laying him down to rest inside the enclosure.

Zoo officials gushed about the happy moment – not just for Calaya, but everyone at the zoo.

‘The birth of this western lowland gorilla is very special and significant, not only to our Zoo family but also to this critically endangered species as a whole,’ Meredith Bastian, curator of primates, said in a statement to the National Zoo’s website.

‘The primate team’s goal was to set Calaya up for success as best we could, given that she is a first-time mother.

‘Doing so required great patience and dedication on the part of my team, and I am very proud of them and Calaya.’

Animal keeper Melba Brown said zoo officials are certain Calaya will be an excellent caregiver to her new son.

‘We will provide support to her if need be, but I have every confidence that Calaya will be a great mom to Moke.

‘This infant’s arrival triggers many emotions—joy, excitement, relief—and pride that all of our perseverance in preparing Calaya for motherhood has paid off.

Primate staff at the Smithsonian National Zoo and Conservation Biology Institute are celebrating the firs birth of a male western lowland gorilla in nine years

‘I am excited to see how he will fit into the group dynamic. There are a lot of different personalities in this family troop, but they all work well together.’

Watch Video Of Heartwarming Moment Gorilla Cradles Her Newborn Baby and Gently Kisses – (NEWS TODAY)

Github: https://github.com/EzzySri/CalDash

Website: caldash.herokuapp.com

Webcast: http://youtu.be/ko8UHuMdacM

Everyday, one has mandatory and flexible events. Mandatory events can be things like class, meetings, or work which requires us to be in specific places at fixed times. Flexible events, well, are more flexible. For example, a person might want to get a haircut, but doesn’t really care when in the day he gets one. Thus, among all the events we face in one day, what is the best way to schedule these flexible events in order to save the most time possible? We created Caldash to solve this problem. Caldash is a calendar app manages your flexible and mandatory events and finds the best schedule that minimizes your walking distance throughout the day.

Currently, we have built out the core of this idea. Caldash can currently optimize events on a current day to minimize distance traveled. However, we cannot currently optimize on any other heuristic, such as minimizing gaps between events or minimizing driving distance as opposed to walking distance. In addition, by the nature of our algorithm, we can only schedule events on every half hour to reduce the number of total possible events and thus the search tree we need to explore in order to find the best schedule. In addition, we tried to generate multiple schedules so that the user can pick the one he likes the best, but this also made the algorithm too slow to run on Heroku. However, Caldash is still very good at what it does currently. It can almost always find the best schedule to save you from walking up those treacherous Berkeley hills.

We used Rails for the backend. At the core of our app, we need to create and then find an optimal schedule events. Creating events is really easy in Rails due to its MVC principles. However, optimizing schedules proved to be the hardest part of the backend. We initially thought we could reduce our problem to the Traveling Salesman Problem since we were essentially trying to find the shortest path between a bunch of locations. However, we had the additional problem that the Traveling Salesman Problem assumes that you can travel from any node in the graph to any other node. In our situation, we couldn’t because only some events can happen after other events, and placements of events were highly dependent on where other events were placed. After realizing this, we tried a different approach. We tried every combination of events that had a distance less than the best schedule’s distance we had found. For example, if we are trying to schedule five events and we found a schedule that has a distance of 500 meters, then we know we can immediately stop exploring any placement of events that has a distance greater than 500 meters. We used euclidean distance to calculate the distance between any two locations.

If we were going to restart the project, we would not have used Rails. While Rails allowed us to quickly create the CRUD portion of our application and provided a bunch of awesome libraries to help us deploy onto Heroku, the major bottleneck for our project was the speed of the optimization algorithm. Because we do explore a significant portion of the search tree that grows exponentially, we had to place a lot of limits that impedes on the user’s experience, such as only allowing the user to place events on every half hour. If we used a faster language that allowed for concurrency (Ruby has the GIL that only allows one thread to execute at a time) such as Scala or Java, we could potentially make the algorithm faster and thus the app better.

We also deployed our final app onto Heroku. Heroku made it insanely easy for us to get something on the web for free. We had to do a bit of refactoring so that Heroku knew how to host our app, but after that, we only had to type git push heroku master to deploy to production. We didn’t explore other features of heroku such as various addons or dyno scalings because those features required money. In future projects, we would use Heroku again, especially if we had a budget that allowed us to use the additional features.

For the front end, React and Flux are the pillars of this portion of the project. Essentially, React is the UI layer while Flux is the data layer. We learned that the benefit of React in reducing complicated program flow is at its best when we strictly maintain the design as the following. The UI side registers actions with the data layer as a set of API endpoints. The triggered actions cause the states at the data layer to change. After all changes are finished, the changes present themselves unidirectionally to UI components from the top down, from which point the React Diff Algorithm takes over.

We add on to the tested benefits, continuing from the discussion we had in the last milestone report. Firstly, it reduces redundant calls to setState. As the web app grows larger, we found that stores become interdependent on computation of data. For example, the Google Map needs current event form input to render the location on the map. Without a store layer, we would need to manage the changes in state in the UI layer itself by passing and receiving states. This complicates program flow and we would end up with more calls to setState simply because it is hard to see the best course of actions in terms of achieving a set of computation. With stores, we are isolated from changes in UI and the computation becomes a traditional program with object representations, class hierarchies and modules and not a web app mixed with css and DOM manipulation, thus allowing us to reason in the same way as when we first learned programming. As a future goal, we will adopt stronger software engineering principles to the front end such as utilizing object factories and class inheritance in Javascript to allow the codebase to scale as we implement more complicated features.

Secondly, isolating the data layer to approximate a traditional program allows us to apply familiar design principles that are not easily relatable in web programming. For example, we did our best to separate computation from service calls. This is because although there are many service calls, the underlying computations tend to be similar. Hence, these computations involving data structures are abstracted out as services themselves to achieve a layered design. Later in the project, we found that many features that we decided to add did not involve refactoring existing codes at all but just adding a few lines of service calls to the same underlying computations. This is not necessarily the case in other frameworks such as Ember, in which actions are contained in controllers when developers are more in the mindset of delivering the result of an action than applying traditional design principles. To summarize, the separation of concerns allow developers to take consideration of the data layer as a whole when delivering an action.

Eric Baldeschwieler: Hadoop in Context

Eric Baldeschwieler, now a private technical advisor in the Valley, led the team at Yahoo who brought Hadoop to the commercial stage. Baldeschwieler described Hadoop as a product built with two primary layers including a computation layer and a distributed file system later. He offered insights into the origins of Hadoop by providing the reason for its conception. Yahoo, one of the major internet networks and largest advertising giant on the web, created Hadoop to crawl and index the internet. The required capabilities for such a robust and mission-critical task included an innate ability to grow in processing power in a flexibly, yet economical manner. Baldeschwieler repeatedly noted that the open source aspect of Hadoop cost quite a bit of money and management resources early on, but serves as a key idea in Hadoop’s scalability and multi-purpose features.

One of main benefits of Hadoop is that it reduces the interaction with databases, the continuous availability of which are essential for both enterprise and consumer-facing applications. A comparison that particularly illustrates the strength and limitation of Hadoop is one with Elasticsearch.  Elasticsearch, for example, relies on indexing and retrieving search results while interacting heavily with the database. Hadoop runs clusters that collect and analyze log data directly from servers so that the load is scattered across all servers instead of concentrated on the database. Elasticsearch excels in small amounts of data, low latency and high availability while Hadoop focuses on tasks involving enormous amount of data and high analytics complexity, such as scientific research and testing of new advertising metrics.

The other key feature that allows Hadoop to prosper is its cost-efficiency. Its processing capabilities are built on cheap Intel commodity servers, which are stripped from all unnecessary accessories except raw computing power. For example, the cheap x86 servers only cost about $4k for each node. This is compared to other relational database deployments which run at a cost of over $10k per terabyte.

A single computer can only go so fast, and certain websites need to handle millions of requests per second in a fast, efficient manner. As a result, modern websites need to be distributed among several servers in order to respond to each request in a timely manner. However, distributed computing is inherently different than computing on a single machine. Instead of just worrying about a single machine performing up to standard, one needs to worry about hundreds of thousands of machines. In addition, these servers must be able to talk and pass information from one another. For example, an error in an one machine must properly propagate to the next. Finally, existing tooling, such as profilers and debuggers,  for programming locally on one machine do not easily carry over to distributed systems. Thus, one needs to create a new abstraction layer to create, monitor, and observe distributed systems. An example is a Future object, which is a unifying abstraction for all asynchronous computation. It is essentially a promise that can succeed or fail, hence requiring client to anticipate and account for both scenarios by declaring onSuccess and onFailure methods. Another powerful feature is sequential composition that is carried out by flatMap. This allows a chain of computations transforming a series of Futures. If any Future along the chain fails, the subsequent Futures will fail automatically without the logic being handled explicitly.

Twitter tackles this problem by breaking their site into a bunch of smaller services. For example, one service could be their search engine, while another service could be monitoring and gathering metrics on different services. Each service can communicate between one another through Finagle. Finagle abstracts away the Relay Procedure Call (RPC) and allows one to easily define API’s that other services can call. Finagle also uses Thrift, which allows one to write different services in different languages. By writing a Thrift configuration file, one can turn a product into a service that other services use. By using Finagle and Thrift, multiple teams at Twitter can chose to utilize different technologies and languages, such as Python, Ruby, Java, or Scala, without breaking each other’s services. Other extensions to the Finagle Thrift services are Ostrich and Zipkin, which handle metrics and performance analytics. It has an admin endpoint which allows inspection of various graphs displaying snapshots of the performance of the Twitter stack, such as latencies and proportion of each method call. Besides breadth, depth of analysis can be achieved with Zipkin. It can trace a request through all its methods and display an intuitive visualization of the latency of each method call.

In addition, Twitter uses Apache Mesos and Apache Aurora to create instances in the datacenter. Suppose a team has one service that requires multiple machines and computing resources while another service only needs one or two. Mesos and Aurora abstracts away the messiness of choosing which machines in the datacenter to run which services. By writing an Aurora configuration file, one can specify how many resources a certain service should get depending on its environment, teams can easily deploy their products without having to worry about if a machine crashes or other jobs that machine is currently running.

Milestone 2 Reflection

Github: https://github.com/EzzySri/CalDash

link: http://caldash.herokuapp.com/ (may not be updated/pushed yet)

Frontend (ReactJS)

In the last milestone, I wrote about the problems of passing down states to a chain of child components and of delegating method calls up the chain of parents since many of the states do not reside in leave components. As our application frontend grows larger and more complicated, there are increasing needs for components to work together. This is especially true in a scheduling app that supports both location and time inputs. This is because instead of relying of stateful URL directions to isolate components, the major components (i.e. map, calendar, event catalog, and input form) need to be on the same page and work in sync with each together since it is hugely inconvenient and slow to change URL when the user wants to inspect each component for information. The interactions need method callbacks and state transfer that cause an exponential growth of the size of the code base. One finds himself reasoning about the effects of states and repetitive calls to setState, violating the React promise as application grows more complicated.

Flux architecture comes to rescue and salvages the React promise of one unique data state representation of one unique UI state. Essentially, the architecture mandates that the unidirectional data flow from the stores in which the state resides to the components via registered actions, which serve as a set of API endpoints for the components. We take the concept to its extreme form and refactor all states to be in the stores. This means that besides the data models such as event assignments and info of the current signed-in user, we also have an application-wide store which keeps the state of seemingly trivial states such as shouldSectionCollapse and didMouseEnterSection, which turn out to be the most effective way to manage highly interactive app. The reduction in complexity is manifested in several ways. Firstly, since these toggles command states across different components, they have to reside in the top level (i.e. Index Component) of the app and act to enable components to act in sync after receiving callbacks from a particular child components. Since they are now in Application Store, the top-level component does not have to hold a large set of states and child components no long have to send callbacks to the chain of parents but instead send the notification to the stores via registered actions directly. In the store layer, relevant states are set within the store and a Change event is emitted at the very end, allowing React magic to occur from the top level down. This adaptation of React allows state manipulation to be completely separate from the component-side and reduces unnecessarily duplicate calls to setState to only one for complex state change. With the separation of concerns and the strict adherence to the mapping of one unique data state to one unique UI state (i.e. rendering a unique result given the same states and props), we can then include PureRenderMixin which adds another degree of performance increase on top of the fast performance guaranteed by the basic React engine.

However, the adoption of Flux architecture does not change without challenges. One of them is that dependencies during initialization of stores are not supported by the currently bare-bone flux implementation. So we resort to a lazy approach of not initializing dependent values, but only recursively query the parent values after the application starts and the dependent values are needed by the components. With power of Flux on top of React, we implement from scratch some universally useful components such as a calendar that supports fetching, addition, deletion and display of events.

Backend

The web has grown and evolved for about a decade since the last major change in HTTP standard in 1999.  It has stayed relevant for the decade despite the lack of innovation precisely because it is so irreplaceable in the entire Internet infrastructure and because of the high switching cost associated with it. So the lack of innovation around HTTP standards seemed understandable. Due to this fact, web developers have been bypassing and hacking around the protocol to allow the old technology to serve its modern day purpose. This purpose has become drastically different since the beginning of the Internet, from what was originally intended for file retrieval to an array of multimedia content. To sum up, HTTP 2.0 will allow improvement in speed, security and resource consumption compared to HTTP 1.1. It is geared towards the same principle that has driven web innovation, which is the concept of backward compatibility. This means that application developers without much expertise of the inner workings of the web do not have to suffer their way through the transition process but can enjoy the benefits using the same syntax and treating the change as a black box. What makes the adoption popular is that HTTP 2.0 does not introduce any change to the API such as adding new header fields or new status codes.  Application code can be completely remained untouched after the switch if developers choose not to take advantage of the strength and efficiency of the new protocol.

HTTP 2.0 is about integrating the existing web practices so that fewer hacks are needed to achieve performance; it is about more elegant and holistic solutions, which are instinctively welcoming for programmers. Here are some examples. Batch methods are often used to fetch multiple resources from backend RESTful APIs because we are familiar with the overhead of individual HTTP requests. What’s more, inlining is used to reduce the number of requests when loading a page as the expense of code readability. HTTP 2.0 integrates these efforts by using multiplexing to enable multiple requests and responses to be on one connection simultaneously. Hence, leaner responses are not blocked by a large chunk of response. Header compression as well as the replacement of text with binaries minimizes the relative high overhead for small requests. This change can drive the consumer shift to mobile computing, in which it is often the case that big request headers often add multiple extra round trips to page loading.

Spontaneous hacks of HTTP 1.1 to squeeze performances often mean less efficient use of web resources. Developers rev up more parallel connections to the server, jamming the Internet traffic as a result. A multiplier effect in resource consumption is trigged again when parallelism is applied to mobile phones, causing more SSL handshakes, mobile network buffers to overload, packets to be dropped and then retransmitted. Because of the ability to multiplex, the new protocol encourages more than one request to be sent at a time to a single connection, reducing the need for parallelism for web pages. Server push predictively sends resources to the client’s cache that the server knows will be requested by the frontend in the near future, reducing round trips and additional requests. This technique also has the added benefits for the increasing dynamic nature of modern apps. For real updates, frontend does not have to overwhelm the server with queries on the latest change. Instead, it can receive invalidations to its cache as data changes. In the lecture, we see that the combination of multiplexing, header compression and cache pushing allows HTTP 2.0 load of images to be consistently faster. Specially in terms of images, even when packages cannot arrive in one chunk, the image appears to be visually recognizable much faster as resources (i.e. parts of the image) can be in flight in the network at the same time.

Software as a service changed how developers create new products. People no longer have to build everything from scratch. For example, if one needs a machine running a specific operating system, one can simply spin one up through Amazon Web Services or any other hosting platform. If one needs to send thousands of text messages to their customers on a regular basis, one can use Twilio for their text messaging service. One does not need to build these systems from scratch but rather use or a buy a service that does this particular function.  As a result, developers can build products much faster with greater reliability by using several of these SaaS products together and focusing the majority of their attention to their business problem.

Noah Zoeschke, one of the founding members of Heroku, spoke about PaaS, what he called the “modern web application stack.” Although app development has gained considerable popularity, all developers, including the most talented programmers in industry, must leverage the perks of PaaS to succeed. Essentially, platform as as service providers such as Heroku enable these developers to create robust applications that can be deployed and maintained in a professional manner. For example, a hospital’s patient database, that requires 100% uptime, could utilize various services provided on their platform of choice to push updates and handle large spikes of traffic without any application downtime. The services are endless, but the path to efficiently creating a versatile app is moving toward simplicity.

However, picking a good SaaS product is hard. For example, suppose a developer needs to send emails to their users every time they receive a message. There are a handful of email services, such as Mailgun, AWS Simple Email Service, SendGrid, and Mailjet, so how does he choose which one to use? In addition, what happens to their product if a service shuts down, goes down for an hour, or removes a key feature that your product depends on? By allowing your product to depend on several outside services, you lose a lot of control and become dependent on several different entities. In addition, one needs to make sure that the service has good documentation; otherwise, one will struggle with using the API correctly, hit an unknown rate limit cap, or pay more money for using the service incorrectly.

Today, Rob Pike of Google presented his flagship product, Go, an open-source Google-sponsored programming language designed for software engineers. While a handful of high-level languages are available to coders, Pike argued the importance of Go’s design due to the nature of industrial languages in connecting every aspect of technology. As an example, Go’s use ranges from Youtube to rendering webpages in Android Google Chrome browsers. Although Youtube and other website content does not appear to directly result from Go’s use, Go’s performance reverberates up to presentation layers users see on their screens. Pike further described the significance Go plays to its makers, Google.

As a Google-made language, Go’s existence erupts from its advantage to Google as a company. The design itself is centered around aiding Google’s thousands of engineers to effortlessly speed up their productivity in their joint projects. An example is Google’s running of computers concurrently to speed up your receival of search results you type. Go is now utilized to find results and get them back to you as fast as possible. In regards to the design, Go prides itself in being readable, suitable, scalable, and toolable for Google’s needs. Readability allows programmers of all-levels to quickly pick up on the actions Go’s lines are making with a cursory glance. A couple intricate efforts on behalf of the Go team to address readability include a simplified scope privacy indication system and a requirement for behavior from outside packages to indicate their foreign directory. As readability improves the success of collaboration between engineers at Google, the end result of improved scalability becomes a reality. In its update to Google’s collaboration infrastructure, Google’s operations and innovations as a whole are able to experience accelerated performance directly from Go’s use. As mentioned above, Go is exceptionally suitable for Google, but toolability is important for developers outside to take advantage of Google’s innovative product. The star feature for Go’s toolability is GOfmt which produces a standard format for Go code styling. The much-loved feature provides a universal recognizable perspective for Go programmers around the world. As Go works its way into widespread public use, the benefits are limitless in the collaboration-focused environment of today’s tech world.