Three energy companies including U.S. Westinghouse, France’s EdF and Korea’s KHNP, have submitted their final bids to build the Czech Republic’s newest reactor at the Dukovany

3 energy companies compete to build a new nuclear reactor in the Czech Republic

The Department of Defense announced pursuit of a B61 gravity bomb variant, pending congressional authorization.

Pentagon pursues new nuclear bomb 24x the power of one dropped during WWII

Forget smoke and mirrors; radio waves and mirrors could be the way forward to check nuclear stockpiles around the world remotely.

Radio waves and mirrors could help build trust between nuclear powers

Hundreds of law enforcement officers descended on southern Maine this week in search of the sole suspect in two separate shootings. Forty-year-old Robert Card of Bowdoin vanished after police say

Search for Maine shooting suspect leveraged old-fashioned footwork and new technology

The incident on Wednesday highlights the dangers Japan still faces in decommissioning the plant that was knocked out by an immense tsunami in 2011 in the world's worst atomic disaster ... For more information go to AFP.com.

Four Japan Nuclear Plant Workers Splashed With Tainted Water

anchored by expert technicians and cutting-edge patented technology, today announces its latest innovation, the Remote, Mobile, and Calibration CoPilot platforms. "We believe it will revolutionize the way ADAS service and calibration businesses manage ...

Opus IVS Unleashes Business and Technician Productivity with Launch of Mobile and Calibration CoPilot

California-headquartered Atom Computing Inc., which opened a Boulder research and development center last year, says it has developed a 1,225-site atomic array populated with 1,180 qubits in its next-generation quantum computing platform that will be released in 2024.

Atom Computing’s record-breaking quantum computer built in Boulder

Bulgaria on Wednesday decided to expand the country’s nuclear power generation as an alternative to fossil fuels by launching the construction of two additional reactors at

Bulgaria is launching the construction of 2 US-designed nuclear reactors

A variety of industries are looking at nuclear power as a way to reduce their carbon footprint and provide a reliable source of electricity. Technology

The POWER Interview: Nuclear Set to Energize, Decarbonize Industry

For complete information about, and access to, our official publications and services, go to About the Federal Register on NARA's archives.gov. The OFR/GPO partnership is committed to presenting accurate and reliable regulatory information on ...

Federal Acquisition Regulation: Cyber Threat and Incident Reporting and Information Sharing

Atomic Object

atomicobject

Data security presents a major challenge of Edge/Fog computing growth. Learn how to overcome issues with the introduction of modern decentralized data layer EdgeFS. We’ve been articulating Edge/Fog computing transformation with arguments in significant cost savings due to reduced bandwidth consumption, improved analytics efficiency due to improved necessary reaction time to events in the physical world, maximum uptime by not relying on WAN (Wide Area Network) like cellular that can be less reliable than wired, and improved security. In terms of security, the benefits come from protecting assets close to the source of data, ones that were never intended to connect to broader networks, much less the internet. However, as applications, data, computing services getting pushed away from centralized locations the data fragments have to be replicated across an increasing number of distributed networks. With that in mind, data security presents still a major challenge of Edge/Fog computing growth. To address these challenges we need conceptually new decentralized data distribution and accessing layers that are designed with Edge/Fog security in mind. Let’s compare two open-source decentralized storage layers designs that might fit the requirement list from data security standpoints: EdgeFS ( , Apache Licensed) and IPFS (the Interplanetary File System , MIT Licensed). http://edgefs.io https://ipfs.io When we designed EdgeFS, data security was our top priority. In EdgeFS, once recorded, data in any given block cannot be altered retroactively as this would invalidate all SHA-3 hashes in the previous blocks in a blockchain-like n-ary tree and break the consensus agreed among decentralized locations. The same can be said about IPFS. EdgeFS built upon the architecture with immutable self-validating location-independent metadata referencing self-validating location-independent payload. While the two storage solutions’ handling of payload chunks is very similar, the differences in how objects are named and found are almost as different as possible. IPFS was designed primarily for peer-to-peer ledger crypto transactions while EdgeFS isn’t making such assumptions and focusing on extream high-performance for many-to-many local or remote content-addressable network operations. The end result of placing a data chunk to IPFS is that it is identified and validated with a strong cryptographic hash and that the cryptographic hash can be used to find the chunk for retrieval. This is very similar to EdgeFS, but there are a few differences: Immutable Payload Chunks IPFS accepts the chunk and then generates its cryptographic hash. A EdgeFS client (via CCOW “Cloud-Copy-On-Write” gateway library API) cryptographically hashes the chunk before requesting that it be put. This avoids transmission of duplicate payload chunks, also known as inline data deduplicationIPFS routing is a consistent hashing solution. EdgeFS instead routes I/O request to a Target Group and then does rapid negotiations within the group to find and dynamically put new chunks on the least burdened targets. This improves capacity balancing, utilization of storage devices, also known as dynamic data placement. EdgeFS FlexHash table is a local site construct. It is automatically discovered and resides in the local site’s server memory. FlexHash is responsible for I/O routing and plays an important role in dynamic load balancing logic. Based on discovered site topology it defines so-called Negotiating Target Groups that are typically formed across 8–24 zoned storage devices to ensure proper failure domain distribution. The IPFS naming system is still a work-in-progress, and examples suggest that IPFS uses a very different method for publishing content accessible by name. Differences in Metadata Philosophy IPFS takes the cryptographic hash of the atomic object and embeds those references in other named objects, which basically function as directories. Each of these directory objects is also immutable, referencing specific frozen-in-time content. The directory object itself has a cryptographic hash, which can be referenced in higher layer directories. Finally, a “root” directory is published which is then pointed to by a mutable name to directory object mapping. I suspect that such design was heavy influenced by the necessity to provide a highly secure persistent layer for cryptocurrency ledger algorithms at the expense of generic storage flexibility and performance. EdgeFS takes a different approach with an objective to enable shared data repository for versioned content that can be accessed and updated simultaneously by thousands of tenant approved users, and with supports for cross-site consistency groups. In EdgeFS, information that supports finding a stored object, by name or by other search criteria, always recorded as metadata separate from the payload. It treats stored payload as opaque blobs with the on-disk organization that doesn’t require to find references within the chunk itself thus allowing client-driven end-to-end encryption. I.e. it presumes that all payload is encrypted and never tries to analyze it. Mutable metadata information always stored locally (local site cluster), thus enabling always-local, immediately consistent I/O policy without sacrificing flexibility or performance. By definition, most metadata about a specific version of an object must be immutable. Certain metadata can be independent of the version contents, such as metadata controlling retention of the object version, local site replication overrides, ACLs, and so on. Immutable Version Metadata One of the strong points for IPFS is that it does not change the storage for a directory object when the mutable naming reference is changed to point at a new version. This is very similar to how EdgeFS handles mutable naming references and in my opinion, is far preferable to the practice of creating an explicitly versioned name. In EdgeFS, mutable naming is always assumed to be local and gets “re-hydrated” upon remote site-to-site transfer. This enables transfers across geographies to be always globally immutable and as such enables global replication that avoids unnecessary networking transfers very efficiently, a.k.a. inline data deduplication over WAN. Summary There are many other features of the modern metadata storage subsystem that are required for versioned content storage that IPFS seems simply does not yet address: The ability to quickly find names that fall within any given folder/directoryPredictable directory or bucket search timesTenant control over access-to and modification-of tenant metadataMetadata driven retention of referenced payload. While I admit that primary and original goals of IPFS were not to serve Edge/Fog computing use cases, its security and global scalability benefits do fit the profile. And perhaps it will catch up one day on the rest of the requirements. But why wait? EdgeFS is available today and it fits the most important requirements for Edge/Fog computing — data security, cost reduction, and performance. EdgeFS exploits locally available site resources and presents them as a highly-available cluster segment that is a part of the geographically decentralized data layer. Outstanding local-site performance characteristics achieved due to its immutable data structure design, dynamic data placement via low latency UDP-based protocol, built-in multi-protocol storage gateways (S3, NoSQL DB, NFS, iSCSI, etc), and highly scalable shared-nothing architecture can be a true enabler of applications that are designed for Edge/Fog computing era. Give it a try today! Star our and let me know what you think? GitHub repository Find out more by joining our growing community at and http://edgefs.io http://rook.io Disclosure:  I'm primary architect and creator of EdgeFS.

Comparison of IPFS and EdgeFS for Secure Edge/IoT Computing use cases

Open source projects have suffered from a lack of reliable and sustainable funding models since the open source movement began. Dedicating one’s energy to open source projects has in the past meant taking a massive hit to one’s pocketbook. The economic incentives were just never there. Doing good for the world has largely been an unpaid martyrdom, great for the soul but terrible for the wallet. A new platform could change all that. It’s called . So, how does it work? Why is a dream funding solution for open source projects? utopian.io utopian.io Short answer: the blockchain. On the platform, contributors to open source projects can be rewarded with the cryptocurrency, STEEM if their submissions follow their guidelines. Some open source projects are , , , and to name just a few. When someone contributes to an open source project via the site, people, as well as the official Steem account can upvote the post, which results in STEEM rewards. There are utopian.io content moderators who ensure that the quality of the post submissions are up to snuff. utopian.io WordPress Steemit busy.org, DTube DSound Zappl utopian.io @utopian-io So, how does someone get involved with ? utopian.io unsplash + utopian logo The first step is to sign up for a free Steem account on . Then, head on over the to the website to get started. You log into with your Steem account and doing so has been determined to be safe. before you start planning your new utopian life, though. Steemit.com utopian.io utopian.io Read the rules The project is integrated with the , so it uses Steem’s built-in voting algorithm to make the reward process run in an autonomous fashion. Steem’s co-founder, Dan Larimer invented the concept of the , or , which was later renamed and popularized by Vitalk Buterin as a , or . utopian.io Steem blockchain DAC Decentralized Autonomous Company DAO Decentralized Autonomous Organization This aspect of makes it like crowdfunding 2.0 on steroids, where decentralized voting is the norm and computer rules determine the final payouts of contributors. Of course, there are still humans deciding which posts to vote for, but the distribution of rewards is handled by an algorithm instead of a central authority. And utopian.io is unique in the Steem ecosystem because it has human content moderators and quality control specialists who make sure that the utopian contributions meet certain standards. utopian.io In addition to coding, one can write articles, create graphic design and do social media campaigns to help bring more visibility to various open source projects. This article is in fact part of this open source collaboration on . utopian.io https://spin.atomicobject.com/2017/10/23/github-releases/ You can also sync your GitHub and utopian.io accounts, thereby connecting them for more cohesiveness. Read more about this in @elear’s post: https://utopian.io/utopian-io/@elear/utopian-is-unstoppable-now-fully-integrated-with-the-github-project-feeds There are many people involved with the building of , as it’s open source as well, and I first read about it from , the founder of utopian.io. utopian.io @elear So, where does the money come from? unsplash The Steem account has just received one million in delegations and is what enables people to earn rewards on Steemit.com and other sites. One STEEM is now roughly equivalent to $1 US dollar. is similar to owning stock in a company, but with one added bonus: you have the ability to give others STEEM without having to actually give away your money. Your personal investment in Steem Power is what decides how the algorithm slices up the reward pool. utopian.io Steem Power Steem Power STEEM Steem Power The more (SP) you have, the more you can influence the algorithm that distributes the daily STEEM rewards. To put this in perspective, my Steem Power is currently 111,000 and this means that if I vote for your post, I can give you roughly $5 of STEEM. But out of that 111,000 STEEM, I have delegated 20,000 of it to a Business Intelligence leader who has low SP. So, it’s similar to giving out a loan that I can take back at any time. Steem Power There are many large account holders who have delegated their SP to the account because they want to support its development and they believe in its mission. Last I heard, the account now has 1 million in Steem Power. This means that the account can vote on open source contributors’ posts, and give them a significant reward in the STEEM cryptocurrency. Steem Power @utopian-io @utopian-io @utopian-io (Clarification: the website is utopian.io and the official Steem account is utopian-io ) is a new project, but I believe it has a very good chance of making a huge difference in the world. Is this the beginning of a new, shared, meritocratic economy? Utopian.io It could be the solution we’ve all been dreaming of. I’m super excited about this because my heart belongs to the world of open source. I never cared much for patents, copyrights and trademarks. About the author: Leah Stephens goes by the pseudonym Stellabelle. She’s a writer, community builder, entrepreneur and blockchain flaneur. She’s currently working on developing an AI chatbot of herself. You can chat now with the AI version of Stellabelle here: https://chatfuel.com/bot/youtubestellabelle Follow her on Steemit: https://steemit.com/@stellabelle I love open source

Could Utopian.io Become The Ultimate Funding Solution For Open Source Projects?

The previous two posts can be found here: DL01: Neural Networks Theory DL02: Writing a Neural Network from Scratch (Code) To understand gradient descent, let’s conisder linear regression. Linear regression is a technique, where given some data points, we try to fit a line through those points and then make predictions by extrapolating that line. The challenge is to find the best fit for the line. For the sake of simplicity, we’ll assume that the output( ) depends on just one input variable( ) i.e. the data points given to us are of the form . y x (x, y) Now we want to fit a line through these data points. The line will obviously be of the form , and we want to find the best values for and This line is called our “hypothesis”. y = mx + b m b. To get started with, and are randomly initialized. Hence, we get a random line in the beginning. Our goal is to update these values so that the resulting line gives least error. We’ll use mean squared error as the , that calculates the error between the actual value output, and prediction from the hypothesis. m b cost function(J) J(m, b) = (1/n) * (yᵢ - (mxᵢ + b))² ∑ where represents the total number of data points and represents the data point ( takes values from 1 to n). n i iᵗʰ i This error function is typically . In simple terms, we can say that this error function typically has just one minimum (the global minimum). convex A convex function The horizontal axes represent the variables on which the function depends, and the vertical dimension represents the output. In our case, the horizontal axes are represented by and , while the vertical axis is represented by m b y. When we start with random values of and , we get some value of correspondingly. Error is minimum at the lowest point on this graph, so our goal is to move down the slope to finally reach the bottom-most point. The question is, how? m b y Before moving on, I’d like you to recall some of your high school maths. The slope of the tangent at any point on a graph is equal to the derivative of the graph w.r.t. input variables. Source: https://spin.atomicobject.com/2014/06/24/gradient-descent-linear-regression/ Now, as you can see, the slope of tangent at the bottom-most point on the graph is 0 i.e. partial derivatives of J at the bottom-most point are 0. To get to the bottom-most point, we have to move in the direction of the slope i.e. we’ll update values of and , such that we eventually get to the optimum values, where error function is minimum. m b The update equations would be as follows: Here, α is called the “learning rate”, and it decides how large steps to take in the direction of the gradient. If the value of α is very small, reaching the optimum value is guaranteed, but it’ll take a lot of time to converge. If α is very large, then the values of and might overshoot the optimal values, and then the error will start to increase instead of decreasing. Hence, learning rate plays an important part in convex optimization. m b A visual representation of gradient descent in action has been shown below: Source: https://alykhantejani.github.io/images/gradient_descent_line_graph.gif How does it work intuitively? For the sake of simplicity, consider an error function that depends on only one variable (or weight) . J w Consider the situation as shown in figure i.e. initial weight is more than the optimal value. Here, initially the slope is large and positive. So, in the update equation, w is reduced. As w keeps getting reduced, notice that the gradient also reduces, and hence the updates become smaller and smaller and eventually, it converges to the minimum. Now consider the situation when the initial weight is less than the optimal value. Here, the slope is negative. So, in the update equation, the value of w increases after every update. Initially, the slope is large, so the updates are large. As w gets increased, the slope keeps getting smaller, and hence the updates keep getting smaller and eventually converge to the minimum. So, in any case, the weights will finally converge to a value such that the derivative of the cost function is 0 (given that the value of alpha is sufficiently less). In this post, I covered gradient descent for linear regression. However, this is the basic idea behind neural networks too. All the weights in the neural network are updated according to this algorithm. Gradient descent is used for optimization in the , which has been covered in the . backpropagation algorithm next post Sometimes the smallest step in the right direction ends up being the biggest step of your life. Gradient Descent 101:

DL03: Gradient Descent

, I compared the performance and memory profiles of a benchmark application written in AngularJS, / and React/Mobx. It’s quite obvious from the metrics that React with Redux or Mobx gives significant performance gains compared to AngularJS. In this post, I will go over the core concepts, benefits and gotchas with both the libraries. In my earlier post React Redux All the below code snippets are from the ticker dashboard application from my earlier post. Redux Redux flow diagram Core Concepts http://redux.js.org/docs/introduction/ThreePrinciples.html Single source of truth (UI State Tree) The of your whole application is stored in an object tree within a single . state store Here is the UI state tree for the stock ticker dashboard application. UI State tree Actions The only way to change the state is to emit an , an object describing what happened. action Action creator is a function returning the action object. In the below example, each Action is represented with a ‘type’ and ‘payload’. Action Creators Reducers To specify how the state tree is transformed by actions, you write pure . reducers Reducers are pure functions that modify the state in immutable way (returns new objects instead of mutating the object). Reducers shouldn’t cause side effects like making external api calls, triggering route changes. Reducers If we design the action interfaces to have a common property (‘ in this example), we can leverage to get type checking as well as the intellisense support in each case statement. type’ TypeScript’s discriminated unions Connected and Pure (Presentational) UI Components _Technically you could write the container components by hand using store.subscribe() . We don't advise you to do this…_redux.js.org Usage with React · Redux React-Redux library provides a Higher order React component which automatically listens for events. When an action is dispatched to the store, Redux will notify the state changed event to all subscribers. All “React-Redux” connected components are subscribers to the Redux store and every connected component’s method is executed with every state change. This method helps you to slice the UI state tree and pick the data needed for the specific component tree. store.subscribe(listener) mapStateToProps Pure components are normal React components. They read data from props to render and execute the callbacks sent via props. They are not aware of Redux or UI state tree. Here is how the component hierarchy would look: Connected Components And Pure Components Here is an example of the connected component. TickerTile component renders stock ticker details (ticker, company name, price, sma, volume etc) and depends on the tickerData as a prop. The parent component just sends the tickerId (e.g. MSFT) as prop (termed as ). The Higher Order connect component takes mapStateToProps mapper function which takes the tickerId and returns tickerData from UI state’s tickerHash and tickerId. ownprops TickerTile React-Redux Connected Component Here is an example of the pure component: Pure Component Pros Everything with Redux is very explicit without any magic. React’s deterministic state changes and view renders are great for testability and easy to debug any issues. Redux patterns force developers to think hard on the schema of the UI state tree. Patterns will be consistent across the codebase (at the cost of verboseness). UI would simply become the representation of the state tree. Changes to the State tree can be easily traced/monitored as the actions play out. Great Documentation and excellent community support. Few things to watch out for Designing UI State tree and try to keep it as flat as possible (instead of deeply nested structures). At times, deciding whether a property should go into the UI state or not can be confusing. Using local component state is fine as long as other parts of the application do not care about it. Make sure your UI state tree is normalized https://twitter.com/dan_abramov/status/727278011591045122 Helpful links: http://redux.js.org/docs/faq/OrganizingState.html#do-i-have-to-put-all-my-state-into-redux-should-i-ever-use-reacts-setstate https://spin.atomicobject.com/2017/06/07/react-state-vs-redux-state/ method of all connected components will be executed with every event of the Redux store. Optimizing this method is one of the critical steps to get optimal performance in complex applications. If you need to execute expensive operations like deriving computed data from the normalized state tree, use Redux reselect library. It memoizes the result and skips recalculating unless input references change (there is a if you’re trying to reuse the selectors in multiple components). Connected Components (containers) mapStateToProps state changed gotcha If there are minimal connected components, props need to be propagated several levels down of the component hierarchy which is clearly not ideal in the large applications. Redux used to recommend connecting few components to the Redux store. Now, the recommendation is to use as many as you need. In the stock ticker dashboard application from my previous post, In the updates test scenario, with 1500 tickerTile (connected) components in the view, Redux refreshed the price/volume changes within 6ms. These two PRs (authored by , creator of Redux) achieved substantial performance gains by connecting several components to Redux store and by optimizing . Dan Abramov mapStateToProps Redux vs mobx — https://github.com/mweststrate/redux-todomvc/pull/1 PixelPaint — https://github.com/dtinth/pixelpaint/pull/1 Helpful Link(s): S ingle connection vs many connections **Batch dispatch calls**Anytime Redux’s dispatch method is called with an action, Redux executes all reducers, updates the state and notifies all the subscribers synchronously. React-Redux will then trigger on all the connected components. mapDispathToProps If you’re updating different sections of the state tree through multiple actions at the same time, try to batch them to trigger only one notification. Helpful Links: https://github.com/markerikson/redux-ecosystem-links/blob/master/store.md#store-change-subscriptions https://github.com/reactjs/redux/issues/2108 http://blog.isquaredsoftware.com/2017/01/idiomatic-redux-thoughts-on-thunks-sagas-abstraction-and-reusability/#multiple-dispatching **Redux Libraries**Redux is a tiny state management library (with minimal API) which acts as a building block for the higher level constructs. You need to bring in a lot of libraries to put together any real world application. It might be overwhelming at first (esp. for folks coming from AngularJS) but most of these libraries are small and come with good documentation. https://github.com/reactjs/reselecthttps://github.com/paularmstrong/normalizrhttps://github.com/omnidan/redux-ignorehttps://github.com/gaearon/redux-thunkhttps://github.com/evgenyrodionov/redux-loggerhttps://github.com/tshelburne/redux-batched-actionshttps://github.com/tappleby/redux-batched-subscribe **Functional Programming**Redux uses several functional programming patterns (currying, higher order functions, composition etc.). The patterns and code might look strange for folks coming from object oriented design background. But Redux comes with a great documentation and there are a ton of great articles/videos out there to gain familiarity with the patterns. Mobx From, https://mobx.js.org/ Both React and MobX provide very optimal and unique solutions to common problems in application development. React provides mechanisms to optimally render UI by using a virtual DOM that reduces the number of costly DOM mutations. MobX provides mechanisms to optimally synchronize application state with your React components by using a reactive virtual dependency state graph that is only updated when strictly needed and is never stale. Mobx flow diagram (source: ) https://mobx.js.org/ Core Concepts https://mobx.js.org/intro/concepts.html Observable State MobX adds observable capabilities to existing data structures like objects, arrays and class instances. Observable State Derivations that can be derived from the without any further interaction is a derivation (user interface, computed values). Anything state User interface derivation OR /* a function that observes the state */autorun(function() {    console.log("Total Tickers",        tickerDataModel.getAllTickers().length    );}); Actions F : rom Mobx’s concepts Actions are functions that state. modify All are updated and when the changes. As a result, it is never possible to observe intermediate values. Derivations automatically atomically state All are updated by default. This means that, for example, can safely inspect a computed value directly after altering the . Derivations synchronously actions state Actions in Mobx Pros A lot less mental overhead (no need to normalize state, no single ui tree, no reducers, no optimizing mapStateToProps, no connected components). Developer velocity and productivity. You can very quickly put together decent sized applications with Mobx and the code also scales well within the large teams. Porting services/view models from AngularJS application would be straight forward. Mobx with React is blazingly fast in scenarios cut out for it. During the updates test scenario ( ), Mobx refreshed price/volume changes with-in 2ms (with 1500 tickers on the page). from my earlier post Few things to watch out for Mobx automatically runs all derivations (updating views, updating computed properties) whenever the state changes. It internally manages the dependency state graph. Its implicit nature of updates feels like magic. This may become problematic in large applications where you might prefer more control. (just my opinion, I may be wrong). , so the external libraries (like lodash) won’t be able to detect Observable arrays correctly. You need to convert to regular Array by calling observable.toJS() or observable.slice(). Observable arrays inherit from Object instead of Array Mobx had higher memory footprint than Redux in some of my test scenarios. This may not be a big deal for most of the applications but please test out your specific scenarios. For promises, and derivations will be triggered for every callback handler. every callback handler needs to wrapped with @action Mobx synchronously triggers derivations whenever an observable property is changed, this can cause performance bottlenecks. right from the beginning helps with this issue. Enforcing strict mode Helpful links: https://medium.com/@mweststrate/becoming-fully-reactive-an-in-depth-explanation-of-mobservable-55995262a254 https://mobx.js.org/best/pitfalls.html Thanks for reading. P.S. Thanks to for reviewing this article. Shyam Arjarapu

Stories, News & Mentions about ATOMICOBJECT

Atomicobject’s Stories on HackerNoon

Atomicobject's News & Mentions