At its premiere in Düsseldorf, the Moody DS48 showed off its enormous amount of space. Many people wondered how such a colossus would sail. We were able to try it out during a light wind test on the Greifswalder Bodden

Moody DS 48: First pictures from the exclusive YACHT test | YACHT

The Boeing 777X test plane is equipped with tons of special equipment, including &quot;The Pit&quot; in the middle of the aircraft. Take a look inside.

I toured an experimental Boeing 777X aircraft, which the planemaker is using to certify the new $442 million widebody. See inside.

(Bloomberg) -- Stocks fell at the end of a jittery week as tech sold off and a pile of options expiring Friday amplified market swings.Most Read from BloombergUS Probing Indian Billionaire Gautam Adani and His Group Over Potential BriberyA $2 Billion Airport Will Test Modi’s Mission, Adani’s ...

Stocks Fall as ‘Triple Witching’ Spurs Volume Jump: Markets Wrap

Learn more about how we test earbuds so you can follow along at home

How we test earbuds at TechRadar | TechRadar

SpaceX’s Starship vehicle lifted off on its third test flight March 14, making significant progress compared to its first two.

Starship lifts off on third test flight - SpaceNews

Experts say there is no way of defining a healthy microbiome and that some currently available tests may risk misleading consumers.

Experts Call For More Regulation Of At Home Microbiome Test Kits

Many patients are reluctant to undergo colonoscopies or conduct at-home fecal tests. Doctors see potential in another screening method.

Colon Cancer Blood Test Shows Promise for Early Detection - The New York Times

Starship, the most powerful rocket ever constructed, achieved multiple milestones during its third test flight before likely breaking apart.

SpaceX’s Starship hits key milestones in test flight but is lost now | CNN

SpaceX&#x27;s Starship rocket, designed to eventually send astronauts to the moon and beyond, completed nearly an entire test flight through space on its third try on Thursday, getting farther than ever before, but disintegrated on its return to Earth.

SpaceX Starship disintegrates after completing most of third test flight | Reuters

SpaceX&#x27;s megarocket reached orbital speed with a space test flight under its belt.

SpaceX launches giant Starship rocket into space on epic 3rd test flight (video) | Space

tset

credit Performance Monitor, or , measures performance statistics on a regular interval, and saves those stats in a file. Perfmon To set it up for Server, do the below steps: SQL Open perfmon from the run Expand Data Collector Sets Right click User Defined Click -> New Data Collector Set Give it a name Click Create manually Click Next -> Create data logs -> Performance counter -> Next Click Add in the next screen Add Available Bytes, Available MBytes, Page faults per second, Pages per second under Memory Add % disk time, Average disk second per read, Average disk second per write, Current disk queue length, disk bytes per second, disk transfer per second under Physical Disk % privileged Time, % processor time under Processor Add Freespace scans per second, Fullscan/sec under SQL Server access methods Add buffer cache hit ratio, checkpoint pages/sec, free pages, lazy writes/sec, page life expectancy under SQL Server buffer manager Add user conections under SQL Server general statistics Add Total latch wait time under SQL Server latches Add Lock timeouts/sec, Lock wait time, number of deadlocks/sec under SQL Server locks Under SQL Server memory manager, add memory grants pending, targe server memory and total server memory Under SQL Server SQL statistics, add batch requests/sec, SQL compilations/sec, SQL re-compilations/sec Under System, add context switches/sec, processor queue length Click OK -> Next -> Next -> Finish Right click this new collector set under User defined and choose start When one needs to see the report, stop this collector and open the collector file and view as report. Source Photos Originally published at xameeramir.github.io .

tSetting Up Perfmon for SQL Server Tuning

How to Solve the Microsoft.Data.SqlClient.SqlException (0x80131904): Incorrect syntax near '$ Error

Change Data Capture (CDC) When There is no CDC

How to Back Fill Data in An Existing Database

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) Dipankar Sarkar, Cryptuon Research and me@dipankar.name Table of Links Abstract and Introduction
Formal Model - Rollups with Decentralized Common Pool (DCP)
Atomic composability & ZK-proofs
Incorporating Zk-proofs
Application of the Formal Model
Conclusion and References 2 Formal Model - Rollups with Decentralized Common Pool (DCP) Addressing the multifaceted nature of blockchain ecosystems, especially those spanning several rollups, demands a structured, rigorous approach to uphold transactional integrity and reliability. To this end, our formal model seeks to methodically dissect and elucidate atomic composability across Ethereum’s multiple rollups. Our model is an amalgamation of classic distributed system theories and innovative cryptographic practices. We recognize that merely adapting traditional system theories to the blockchain milieu is not sufficient, necessitating a model tailored for the peculiarities of decentralized ledgers, especially within Ethereum’s ecosystem ([9]. Subsequent sections will delve into the intricacies of our formal model, commencing with fundamental definitions. We will then probe into operational dynamics, examining transactional workflows, dependency resolutions, and concurrency nuances. Cryptographic methodologies, particularly zeroknowledge proofs, will be highlighted, underscoring their pivotal role in efficient, confidential transaction validations. With this formal model, our aspiration is to furnish readers with an encompassing, lucid, and rigorous comprehension of how to establish, sustain, and, if necessary, re-establish atomic composability in environments with multiple rollups. 2.1 Definitions • R: Set of rollups on Ethereum. • T: Set of transactions, where Ti,j is the j-th transaction on rollup Ri. • Pd: Decentralized common pool. • K: Set of cryptographic keys associated with transactions. • τ : Timestamp attached to each transaction when it’s accepted by the majority of Pd nodes. • B: Buffer zone where transactions with pending dependencies are stored. • τmax: Maximum time a transaction can reside in buffer B. • Bmax: Maximum number of transactions that can reside in buffer B. • Dmax: Maximum number of attempts to resolve a transaction’s dependencies. 2.2 Operations 2.2.1 Publish • Description: This operation ensures that every transaction Ti,j from rollup Ri is published to the Decentralized Common Pool Pd. • Steps: 1. Ri generates a transaction Ti,j . 2. Ri sends Ti,j to Pd. 3. On receiving Ti,j , the majority of nodes in Pd timestamp it with τ and store it. • Output: publish(Ti,j ) → Pd(τ ) 2.2.2 Buffer • Description: Transactions with unmet dependencies are sent to the buffer B until their dependencies are resolved or they hit one of the defined limits. • Steps: 1. If Ti,j has unresolved dependencies, it’s directed to B. 2. Ti,j resides in B until either its dependencies are resolved or it breaches one of the constraints (τmax, Bmax, or Dmax). • Output: buffer(Ti,j ) → B 2.2.3 Resolve • Description: The operation checks for and resolves dependencies between two transactions, possibly from different rollups. • Steps: 1. Given two transactions Ti,j and Tk,l, Pd checks for their mutual dependencies. 2. If dependencies exist, Pd attempts resolution based on available data and timestamps. 3. If resolution is successful within the constraints, the transactions proceed. Otherwise, they remain in B or are rejected. • Output: resolve(Ti,j , Tk,l) → bool 2.2.4 Verify • Description: Ensures the validity and authenticity of the transaction using cryptographic keys. • Steps: 1. For each transaction Ti,j , Pd uses the associated cryptographic key Ki,j to verify its authenticity and integrity. 2. If the verification succeeds, the transaction proceeds. Otherwise, it’s deemed invalid. • Output: verify(Ti,j , Ki,j ) → bool 2.3 Transaction Processing For two transactions Ti,j from Ri and Tk,l from Rk: 2.3.1 Timestamp-Based Handling If both transactions are timestamped in Pd and their timestamps are within an acceptable time difference (delta): Then, the transactions are deemed compatible and can be processed without buffering. 2.3.2 Buffering • If the timestamp difference exceeds the acceptable delta, or if there’s a dependency which isn’t yet satisfied, transactions are sent to B. • While in B: – Periodic checks are done to see if dependencies can now be resolved. – If (τcurrent − τ (Ti,j )) > τmax, Ti,j is rejected. – If the buffer size exceeds Bmax, a rejection policy PR is triggered to create space. – If attempts to resolve dependencies for Ti,j exceed Dmax, Ti,j is rejected. 2.3.3 Rejection and Notification Once a transaction is rejected, a notification mechanism informs the originating rollup Ri or the respective party about the rejection. This allows for potential re-submission or other actions from the user’s end. 2.4 Rollup Punitive Measures 2.4.1 Staking Mechanism Every rollup must stake a certain number of tokens to participate in the transaction composability system. This stake acts as collateral that can be forfeited or slashed if the rollup misbehaves. 2.4.2 Monitoring and Reporting Third-party nodes or participants (often called "watchers" or "validators") can monitor transactions and execution behaviors across rollups. If they detect a rollup executing a transaction without proper validation or not adhering to the model’s rules, they can submit a proof of this misbehavior. 2.4.3 Misbehavior Proof A system can be put in place to accept proofs of misbehavior. Once verified, punitive measures can be enacted on the misbehaving rollup, including forfeiting their staked tokens. 2.5 Decentralized Common Pool (DCP) Instead of having a centralized common pool, we can utilize a decentralized common pool, Pd. This pool would be maintained and updated by a network of nodes, ensuring redundancy and security. Utilizing a consensus mechanism, these nodes can agree on the state of the pool. 2.5.1 Core features • Consensus Mechanism: Nodes in the Pd network use a consensus mechanism (like PoS, PoA, or a Byzantine Fault Tolerance mechanism) to validate and agree on the state of the pool. This prevents any single entity from maliciously modifying the data. • Data Redundancy: The decentralized nature ensures that multiple copies of the transaction pool are stored across nodes. This redundancy makes it resistant to single points of failure and data tampering. • Cryptographic Verification: Apart from using cryptographic keys for transaction verification, node participation, data propagation, and pool updates in the Pd network are also secured using cryptographic techniques, ensuring data integrity and authenticity. 2.5.2 Concurrency Handling with Transaction Delay/Rejection • Timestamping: Each transaction that’s published to Pd is timestamped. This timestamp is based on when the transaction is received by the majority of nodes in the Pd network. • Transaction Buffer: Transactions that have dependencies across rollups are not immediately processed. Instead, they’re placed in a buffer zone. • Dependency Resolution with Buffer: During the resolution phase, the system checks the buffer to resolve dependencies. If Transaction Ti,j depends on Transaction Tk,l, the system will: – Check if both transactions are in the buffer and if their timestamps are within an acceptable time difference (delta). – If they are, the system processes both transactions. – If not, and if the dependency can’t be resolved within a certain timeframe, the system might either: 1. Reject one or both of the transactions. 2. Delay the transaction processing until the dependency is resolved or a timeout occurs. 2.5.3 Challenges With the incorporation of a decentralized common pool, timestamping, a transaction buffer for dependency resolution, and enhanced security measures, the solution addresses many of the concurrency and security concerns. However, it’s essential to consider trade-offs: • The system might have increased complexity due to decentralization and consensus mechanisms. • Transaction delays, while managing concurrency, might not be suitable for applications that require real-time processing. • Ensuring all nodes in the Pd network are updated in near real-time might present scalability challenges. This paper is available on arxiv under CC 4.0 license. Authors: (1) Dipankar Sarkar, Cryptuon Research and me@dipankar.name This paper is available on arxiv under CC 4.0 license. Authors: Authors: (1) Dipankar Sarkar, Cryptuon Research and me@dipankar.name Table of Links Abstract and Introduction Formal Model - Rollups with Decentralized Common Pool (DCP) Atomic composability & ZK-proofs Incorporating Zk-proofs Application of the Formal Model Conclusion and References Abstract and Introduction Abstract and Introduction Formal Model - Rollups with Decentralized Common Pool (DCP) Formal Model - Rollups with Decentralized Common Pool (DCP) Atomic composability & ZK-proofs Atomic composability & ZK-proofs Incorporating Zk-proofs Incorporating Zk-proofs Application of the Formal Model Application of the Formal Model Conclusion and References Conclusion and References 2 Formal Model - Rollups with Decentralized Common Pool (DCP) Addressing the multifaceted nature of blockchain ecosystems, especially those spanning several rollups, demands a structured, rigorous approach to uphold transactional integrity and reliability. To this end, our formal model seeks to methodically dissect and elucidate atomic composability across Ethereum’s multiple rollups. Our model is an amalgamation of classic distributed system theories and innovative cryptographic practices. We recognize that merely adapting traditional system theories to the blockchain milieu is not sufficient, necessitating a model tailored for the peculiarities of decentralized ledgers, especially within Ethereum’s ecosystem ([9]. Subsequent sections will delve into the intricacies of our formal model, commencing with fundamental definitions. We will then probe into operational dynamics, examining transactional workflows, dependency resolutions, and concurrency nuances. Cryptographic methodologies, particularly zeroknowledge proofs, will be highlighted, underscoring their pivotal role in efficient, confidential transaction validations. With this formal model, our aspiration is to furnish readers with an encompassing, lucid, and rigorous comprehension of how to establish, sustain, and, if necessary, re-establish atomic composability in environments with multiple rollups. 2.1 Definitions 2.1 Definitions • R: Set of rollups on Ethereum. • T: Set of transactions, where Ti,j is the j-th transaction on rollup Ri. • Pd: Decentralized common pool. • K: Set of cryptographic keys associated with transactions. • τ : Timestamp attached to each transaction when it’s accepted by the majority of Pd nodes. • B: Buffer zone where transactions with pending dependencies are stored. • τmax: Maximum time a transaction can reside in buffer B. • Bmax: Maximum number of transactions that can reside in buffer B. • Dmax: Maximum number of attempts to resolve a transaction’s dependencies. 2.2 Operations 2.2 Operations 2.2.1 Publish 2.2.1 Publish • Description: This operation ensures that every transaction Ti,j from rollup Ri is published to the Decentralized Common Pool Pd. • Steps: • Steps: 1. Ri generates a transaction Ti,j . 2. Ri sends Ti,j to Pd. 3. On receiving Ti,j , the majority of nodes in Pd timestamp it with τ and store it. • Output: publish(Ti,j ) → Pd(τ ) 2.2.2 Buffer 2.2.2 Buffer • Description: Transactions with unmet dependencies are sent to the buffer B until their Description: dependencies are resolved or they hit one of the defined limits. • Steps: • Steps: 1. If Ti,j has unresolved dependencies, it’s directed to B. 2. Ti,j resides in B until either its dependencies are resolved or it breaches one of the constraints (τmax, Bmax, or Dmax). • Output: buffer(Ti,j ) → B 2.2.3 Resolve 2.2.3 Resolve • Description: The operation checks for and resolves dependencies between two transactions, possibly from different rollups. • Description: • Steps: • Steps: 1. Given two transactions Ti,j and Tk,l, Pd checks for their mutual dependencies. 2. If dependencies exist, Pd attempts resolution based on available data and timestamps. 3. If resolution is successful within the constraints, the transactions proceed. Otherwise, they remain in B or are rejected. • Output: resolve(Ti,j , Tk,l) → bool • Output: 2.2.4 Verify 2.2.4 Verify • Description: Ensures the validity and authenticity of the transaction using cryptographic • Description: keys. • Steps: • Steps: 1. For each transaction Ti,j , Pd uses the associated cryptographic key Ki,j to verify its authenticity and integrity. 2. If the verification succeeds, the transaction proceeds. Otherwise, it’s deemed invalid. • Output: verify(Ti,j , Ki,j ) → bool • Output: 2.3 Transaction Processing 2.3 Transaction Processing For two transactions Ti,j from Ri and Tk,l from Rk: 2.3.1 Timestamp-Based Handling 2.3.1 Timestamp-Based Handling If both transactions are timestamped in Pd and their timestamps are within an acceptable time difference (delta): Then, the transactions are deemed compatible and can be processed without buffering. 2.3.2 Buffering 2.3.2 Buffering • If the timestamp difference exceeds the acceptable delta, or if there’s a dependency which isn’t yet satisfied, transactions are sent to B. • While in B: – Periodic checks are done to see if dependencies can now be resolved. – If (τcurrent − τ (Ti,j )) > τmax, Ti,j is rejected. – If the buffer size exceeds Bmax, a rejection policy PR is triggered to create space. – If attempts to resolve dependencies for Ti,j exceed Dmax, Ti,j is rejected. 2.3.3 Rejection and Notification 2.3.3 Rejection and Notification Once a transaction is rejected, a notification mechanism informs the originating rollup Ri or the respective party about the rejection. This allows for potential re-submission or other actions from the user’s end. 2.4 Rollup Punitive Measures 2.4 Rollup Punitive Measures 2.4.1 Staking Mechanism 2.4.1 Staking Mechanism Every rollup must stake a certain number of tokens to participate in the transaction composability system. This stake acts as collateral that can be forfeited or slashed if the rollup misbehaves. 2.4.2 Monitoring and Reporting 2.4.2 Monitoring and Reporting Third-party nodes or participants (often called "watchers" or "validators") can monitor transactions and execution behaviors across rollups. If they detect a rollup executing a transaction without proper validation or not adhering to the model’s rules, they can submit a proof of this misbehavior. 2.4.3 Misbehavior Proof 2.4.3 Misbehavior Proof A system can be put in place to accept proofs of misbehavior. Once verified, punitive measures can be enacted on the misbehaving rollup, including forfeiting their staked tokens. 2.5 Decentralized Common Pool (DCP) 2.5 Decentralized Common Pool (DCP) Instead of having a centralized common pool, we can utilize a decentralized common pool, Pd. This pool would be maintained and updated by a network of nodes, ensuring redundancy and security. Utilizing a consensus mechanism, these nodes can agree on the state of the pool. 2.5.1 Core features 2.5.1 Core features • Consensus Mechanism: Nodes in the Pd network use a consensus mechanism (like PoS, PoA, or a Byzantine Fault Tolerance mechanism) to validate and agree on the state of the pool. This prevents any single entity from maliciously modifying the data. • Data Redundancy: The decentralized nature ensures that multiple copies of the transaction pool are stored across nodes. This redundancy makes it resistant to single points of failure and data tampering. • Cryptographic Verification: Apart from using cryptographic keys for transaction verification, node participation, data propagation, and pool updates in the Pd network are also secured using cryptographic techniques, ensuring data integrity and authenticity. 2.5.2 Concurrency Handling with Transaction Delay/Rejection 2.5.2 Concurrency Handling with Transaction Delay/Rejection • Timestamping: Each transaction that’s published to Pd is timestamped. This timestamp is based on when the transaction is received by the majority of nodes in the Pd network. • Transaction Buffer: Transactions that have dependencies across rollups are not immediately processed. Instead, they’re placed in a buffer zone. • Dependency Resolution with Buffer: During the resolution phase, the system checks the buffer to resolve dependencies. If Transaction Ti,j depends on Transaction Tk,l, the system will: – Check if both transactions are in the buffer and if their timestamps are within an acceptable time difference (delta). – If they are, the system processes both transactions. – If not, and if the dependency can’t be resolved within a certain timeframe, the system might either: 1. Reject one or both of the transactions. 2. Delay the transaction processing until the dependency is resolved or a timeout occurs. 2.5.3 Challenges 2.5.3 Challenges With the incorporation of a decentralized common pool, timestamping, a transaction buffer for dependency resolution, and enhanced security measures, the solution addresses many of the concurrency and security concerns. However, it’s essential to consider trade-offs: • The system might have increased complexity due to decentralization and consensus mechanisms. • Transaction delays, while managing concurrency, might not be suitable for applications that require real-time processing. • Ensuring all nodes in the Pd network are updated in near real-time might present scalability challenges.

Towards Universal Atomic Composability: Formal Model - Rollups with Decentralized Common Pool (DCP)

The Golden Locket

In this post, we will see how an action can be dispatched using Redux on login, and set the app state accordingly. Assuming familiarity with React Native and Redux concepts We have the following Login component to begin with : React, { useState } ; { View, Button, Text } ; CustomButton ; InputField ; { styles } ; Login = { [username, setUsername] = useState( ); [password, setPassword] = useState( ); ( <InputField
        placeholder='Enter username'
        value={username}
        onChangeText={(text) => setUsername(text)}
      />
      <InputField
        placeholder='Enter password'
        secureTextEntry={true}
        value={password}
        onChangeText={(text) => setPassword(text)}
      />
      <CustomButton 
        title='Sign In' 
        onPress={() => }  
      />
  );
};

export default Login; import from 'react' import from 'react-native' import from '../../components/CustomButton' import from '../../components/InputField' import from './style' const ( ) => props // remove these initial assignments after testing const '' const '' return < > View Right now it doesn’t do anything, it’s just barebones UI. To make it “react” to user action we should update the paramter in the button. onPress SignIn <CustomButton title= onPress={() => } /> 'Sign In' We use here, so pressing the button should dispatch and action to the reducer which should in turn update the overall app's state. redux For sake of simplicity, all redux code is placed in a ‘ ’ folder, while the components are in ‘ ’. redux src/components/<ComponentName>/index.js This is how our folder looks like. redux ├── actions.js ├── actionTypes.js ├── initialState.js ├── reducer.js └── store.js redux Let’s set as follows. These are all the fields that our login API will return (yours may differ). initialState and in are flags that we will set on our own (these are not part of API response) userId isLogged initialState = { : , : , : , : , : , : ,
}; export const isLoggedIn false userId '' token '' refreshToken '' expiresOn '' data '' Define action type in actionTypes.js SET_LOGIN_STATE = export const "SET_LOGIN_STATE" Let’s now create our in loginReducer reducer.js { initialState } ; * t ; loginReducer = { (action.type) { t.SET_LOGIN_STATE: {
        ...state,
        ...action.payload, isLoggedIn: , }; : state;
  }
}; import from './initialState' import as from './actionTypes' export const ( ) => state = initialState, action switch case return // this is what we expect to get back from API call and login page input true // we set this as true on login default return We can now generate our redux store using all the available information and thunk as middle-ware to handle API calls. thunkMiddleware ; { createStore, combineReducers, applyMiddleware } ; { composeWithDevTools } ; { loginReducer } ; rootReducer = combineReducers({ : loginReducer,
}); store = createStore(
  rootReducer,
  composeWithDevTools(applyMiddleware(thunkMiddleware))
); import from 'redux-thunk' import from 'redux' import from 'redux-devtools-extension/developmentOnly' // this is for debugging with React-Native-Debugger, you may leave it out import from './reducer' const loginReducer export const We have these things in place but we still have not figured how to set the state from the Login component. For this we need to define some actions in actions.js What we are looking at is a function that can call the login API and return the result back to us. Something like : fetch(LoginUrl, { : , : { : , : ,
      }, : .stringify(loginInput),
    })
    .then()
................... return method 'POST' headers Accept 'application/json' 'Content-Type' 'application/json' body JSON But we also need to ensure that the action is “connected” to the “reducer” in order to update the state or store. redux Since API call is considered unpredictable, it should not dispatch the action object directly to reducer, but through a helper. Dispatching action can return only an Object. If it returns a promise the app will break. We need to make sure of this. In : actions.js * t ; { LoginUrl } ; setLoginState = { { : t.SET_LOGIN_STATE, : loginData,
  };
}; import as from './actionTypes' import from '../constants/Api' // this is what our action should look like which dispatches the "payload" to reducer const ( ) => loginData return type payload To fetch this in the action above, we create another function using the fetch operation discussed above: loginData { Alert } ; login = { { username, password } = loginInput; { fetch(LoginUrl, { : , : { Accept: , : ,
      }, : .stringify(loginInput),
    })
      .then( response.json())
      .then( { (json.msg === ) { dispatch(setLoginState({ ...json, : username })); } {
          Alert.alert( , );
        }
      })
      .catch( {
        Alert.alert( , ); .log(err);
      });
  };
}; import from 'react-native' // to show alerts in app export const ( ) => loginInput const return ( ) => dispatch // don't forget to use dispatch here! return method 'POST' headers // these could be different for your API call 'application/json' 'Content-Type' 'application/json' body JSON ( ) => response ( ) => json if 'success' // response success checking logic could differ userId // our action is called here else 'Login Failed' 'Username or Password is incorrect' ( ) => err 'Login Failed' 'Some error occured, please retry' console You can see how our action is dispatched from this function, which in turn will return a payload object to the reducer in order to perform state update. Only thing remaining now is connecting this function to the UI. Let’s go back to our component in the Submit button section and specify Login onPress { useDispatch } ; { login } ;

...............

<CustomButton 
        title= onPress={() => useDispatch(login({ : username, : password }))}  
      />
............... import from 'react-redux' import from '../../redux/actions' 'Sign In' 'username' 'password' Since we are using here, all our functions should ideally be in form of some action, which will be caught in the middleware first and then passed on appropriately to reducer. redux redux-thunk On successful login, the values will all be populated. On failure, an alert will show up stating error. initialState I hope this was helpful & informative :) Also published at https://dev.to/skd1993/creating-a-simple-login-function-with-redux-and-thunk-in-react-native-33ib

Smart Strategy To Create Login Function in React Native Using Powerful Tools

How To Connect MariaDB Docker Containers with Java Spring And JDBC

Whether or not you've been actively developing within one of the or not, you've likely at least heard of the concept of by now. If not, I certainly encourage you to do a little research into the whole idea of using . JVM languages reactive programming declarative programming data streams In this article we'll take a look at the (very) brief background of not only what Reactive Relational Database Connectivity (R2DBC) is but it exists, and then dive into the code to see how the new can be used to create fully reactive, applications! why MariaDB R2DBC connector Java Spring We're going to walking through the process of creating a simple todo application, but if you'd prefer to jump directly into the code you can find it . here It all starts with Reactive Streams While I'm not going to give you the backstory and technical details behind reactive programming, it's important that we go over a few of the high level points before diving to all the hoopla. entire R2DBC For starters, it's important to know (or recall, depending on your current circumstance) that reactive programming boils down to the idea of using asynchronous data streams. A data stream is basically what it sounds like, a stream of data. But what does that really mean exactly? A stream is a sequence of ongoing events ordered in time. There are three types of events; value, error, completed signal. While we could certainly dive even deeper into the plethora of use cases for data streams, that's a little out of scope for this walk-through (I promise all of this is culminating to a walk-through). Instead we're going to focus on that the structure of a data stream is what brings the concept of to life. reactive streams Ok, ok, I know what you're thinking; "Damn, this dude is throwing around the word reactive more than a Midwesterner roaming through a crowd using the word ' '". Bear with me, there's a point to all this madness. I promise! ope Reactive Streams is simply a standard for asynchronous stream processing using the idea of non-blocking back pressure. "Seriously, Rob! Back pressure?! Are you just making things up now? I think I'm getting back pressure just reading this nonsense." No, I'm not just messing with you. You can think of back pressure as a way of the receiving side (of a data stream) telling the sending side when they are ready for more information and how much to send. Back pressure is an important concept because it's the foundation of which the reactive streams initiative is built on. Keeping out of the gritty details, the key takeaway here is that Reactive Streams is a set of specifications, or rules, used to define the way asynchronous streams are managed. - reactive streams creates a standard approach. TL;DR The following (very high level) diagram shows the interactions (to manage, yep, you guessed it, data streams!) between publishers and subscribers. For more information on reactive streams, specification came about, the interfaces involved and analysis on use cases, I encourage you to take a look at the . why this write-up by John Thompson For our purposes, we're interested in the specification itself, specifically how it's utilized with Reactive Relational Database Connectivity (R2DBC). R2DBC to the rescue R2DBC started as an experiment and proof of concept to enable integration of SQL databases into systems that use reactive programming models. It's necessary because of limitations of the API. Java Database Connectivity (JDBC) According to the : http://r2dbc.io "R2DBC specifies a that is intended to be implemented by driver vendors and used by client libraries. By using the R2DBC SPI, applications written in a JVM programming language can run SQL statements and retrieve results by using an underlying data source." service-provider interface (SPI) And if you haven't guess by now, the R2DBC SPI is based on and uses the concepts of publishers and subscribers to allow non-blocking back-pressure-aware data access. Ah, yes, we've come full circle! Reactive Streams - R2DBC is a new connectivity specification that supports reactive interactions all the way to the database level. TL;DR recently released their R2DBC connector implementation. It's completely and follows the MariaDB Corporation open-source R2DBC 0.8.1 specifications. This is where you ceremoniously crack your knuckles. It's time to code! Requirements Before jumping into code, you're going to need to make sure you have a few things on your machine: MariaDB Client Docker Java (v. 8+) (for testing the API endpoints) Curl Getting Started with MariaDB Let's assume you've either never used MariaDB or don't currently have an instance running on your machine. No problem! It only takes a couple of minutes, using a Docker container, to get MariaDB up and running. If you've already got an instance running feel free to skip down to the part where we create a new schema. To pull the and spin up a container simply open a terminal window and run the following: MariaDB Server image $ docker run -p 3306:3306 -d --name mariadb -eMARIADB_ROOT_PASSWORD=Password123! mariadb/server:10.4 The previous command will spin up a MariaDB Server container that you can connect to and communicate with using the . MariaDB client There are many SQL clients available out in the wild. For simplicity's sake, I've chosen to demonstrate how to use the official MariaDB Client, but certainly feel free to use whatever client you prefer. Connect to your MariaDB instance by executing the following command in a terminal window. You should see something like the following, which means you've successfully connected to the MariaDB instance! Next, create a new database for our TODO application. todo; CREATE DATABASE Then create a new table to store our tasks. todo.tasks ( , description ( ), completed ); CREATE TABLE id int varchar 200 boolean Getting reactive with R2DBC With a database instance spun up and schema created you're ready to create a fully-reactive application. Java Create a Maven project Start by navigating to , which will enable you to create a new -based project. https://start.spring.io Spring Maven For this project you can enter the following criteria. Next, add the following dependencies: Finally, click the "GENERATE" button to create and download the project (contained within a .zip file) to a desired location on your machine. Add the MariaDB R2DBC connector Navigate to the location where you downloaded the new Maven project (.zip file) to, and unzip.  Then use a code editor to open the project, and open pom.xml. Add a new dependency for MariaDB's R2DBC connector to the collection of dependencies. org.mariadb r2dbc-mariadb 0.8.2-alpha2 < > dependency < > groupId </ > groupId < > artifactId </ > artifactId < > version </ > version </ > dependency The MariaDB R2DBC connector is not available in the Spring dependencies listing because it's currently still in the alpha phase of development. Preparing the data integration Now that you've created a project that contains all of the dependencies you'll need, it's time to start really coding. Typically, I like to start by creating the entity (or model) classes. Navigate to /src/main/java/com/example/todo , create a new folder called "models", and create a new file within it named "Task.java". Open "Task.java" and add the following code. com.mariadb.todo.models; org.springframework.data.relational.core.mapping.Table; lombok.Data; ( ) { Integer id; String description; Boolean completed;
} package import import // Lombok annotation that eliminates getter/setter boilerplate code @Data // Annotation that will point to table "tasks" (pluralized in the database) @Table "tasks" public class Task @Id private private private Next, create a new folder called "repositories" in , and create a new filed within it named "TasksRepository.java" /src/main/java/com/mariadb/todo Open "TasksRepository.java" and add the following code. com.mariadb.todo.repositories; com.mariadb.todo.models.Task; org.springframework.data.repository.reactive.ReactiveCrudRepository; {
} package import import // Registered as a Spring Repository (Component) // Repository = a mechanism for encapsulating storage, retrieval, and search behavior which emulates a collection of objects public < , > interface TasksRepository extends ReactiveCrudRepository Task Integer The interface provides CRUD operations on a repository for a specific type, and follows reactive paradigms and uses types which are built on top of Reactive Streams. ReactiveCrudRepository Project Reactor Setting up the connection configuration As previously mentioned, in order to create a connection to a database using R2DBC you must first create a . The MariaDB implementation of the ConnectionFactory interface is called and it requires a instance, which contains a variety of configuration details used to connect to a MariaDB database instance. ConnectionFactory MariadbConnectionFactory MariadbConnectionConfiguration Create a new folder called "config" in , and create a new filed within it named "R2DBCConfig.java" /src/main/java/com/mariadb/todo Open "R2DBCConfig.java" and add the following code. com.mariadb.todo.config; org.mariadb.r2dbc.MariadbConnectionConfiguration; org.mariadb.r2dbc.MariadbConnectionFactory; org.mariadb.r2dbc.SslMode; org.springframework.context.annotation.Bean; org.springframework.context.annotation.Configuration; org.springframework.data.r2dbc.config.AbstractR2dbcConfiguration; org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories; java.io.IOException; java.io.InputStream; java.util.Properties; 2dbcRepositories { {
		ClassLoader loader = Thread.currentThread().getContextClassLoader();
		Properties props = Properties(); (InputStream f = loader.getResourceAsStream( )) {
			props.load(f); MariadbConnectionFactory(MariadbConnectionConfiguration.builder()
				.host(props.getProperty( ))
				.port(Integer.parseInt(props.getProperty( )))
				.username(props.getProperty( ))
				.password(props.getProperty( ))
				.database(props.getProperty( ))
				.build());
		} (IOException e) {
			System.out.println(e.getMessage()); ;
		}
	}
} package import import import import import import import import import import @Configuration @EnableR public class R2DBCConfig extends AbstractR2dbcConfiguration @Override @Bean MariadbConnectionFactory public connectionFactory () new try "db.properties" return new "host" "port" "username" "password" "database" catch return null Notice that R2DBCConfig retrieves the database connection details from a file called "db.properties". To add the connection configuration navigate to , create a new file called "db.properties" and add the following code. /src/main/java/com/mariadb/resources host=127.0.0.1
port=3306
username=USERNAME_HERE
password=PASSWORD_HERE
database=todo Although not recommended you can add connection details directly to R2DBCConfig.java. Create a data service Services can be used to manage the business logic of your application. The only service, TasksService, in this application is used for validating a Task object and integrating with the TasksRepository. Create a new folder called "services" in , and create a new filed within it named "TasksService.java" /src/main/java/com/mariadb/todo Open "TasksService.java" and add the following code. com.mariadb.todo.services; com.mariadb.todo.models.Task; com.mariadb.todo.repositories.TasksRepository; org.springframework.beans.factory.annotation.Autowired; org.springframework.stereotype.Service; org.springframework.transaction.annotation.Transactional; reactor.core.publisher.Flux; reactor.core.publisher.Mono; { TasksRepository repository; { (task != && !task.getDescription().isEmpty()) { ;
        } ;
    } { .repository.findAll();
    } { .repository.save(task);
    } { .repository.findById(task.getId())
                .flatMap(t -> {
                    t.setDescription(task.getDescription());
                    t.setCompleted(task.getCompleted()); .repository.save(t);
                });
    } { .repository.findById(id)
                .flatMap( .repository::delete);
    }
} package import import import import import import import // Registered as a Spring Service (Component) @Service public class TaskService // Automatically instantiate (via Spring IoC) @Autowired private // Boolean public isValid ( Task task) final if null return true return false // Get all records from the tasks table Flux<Task> public getAllTasks () return this // Save a new task record Mono<Task> public createTask ( Task task) final return this // Update an existing task record @Transactional Mono<Task> public updateTask ( Task task) final return this return this // Delete the task record by specified id @Transactional Mono<Void> public deleteTask ( id) final int return this this Expose API endpoints Finally, you'll need to create a controller to expose four endpoints that can be used to perform the basic CRUD operations on your Tasks. Create a new folder called "controllers" in , and create a new filed within it named "TasksController.java" /src/main/java/com/mariadb/todo Open "TasksController.java" and add the following code. com.mariadb.todo.controllers; com.mariadb.todo.models.Task; com.mariadb.todo.services.TaskService; org.springframework.beans.factory.annotation.Autowired; org.springframework.http.HttpStatus; org.springframework.http.ResponseEntity; org.springframework.web.bind.annotation.DeleteMapping; org.springframework.web.bind.annotation.GetMapping; org.springframework.web.bind.annotation.PostMapping; org.springframework.web.bind.annotation.PutMapping; org.springframework.web.bind.annotation.RequestBody; org.springframework.web.bind.annotation.RequestMapping; org.springframework.web.bind.annotation.RequestParam; org.springframework.web.bind.annotation.RestController; reactor.core.publisher.Flux; reactor.core.publisher.Mono; ( ) { TaskService service; () ResponseEntity<Flux<Task>> get() { ResponseEntity.ok( .service.getAllTasks());
    } () ResponseEntity<Mono<Task>> post( Task task) { (service.isValid(task)) { ResponseEntity.ok( .service.createTask(task));
        } ResponseEntity.status(HttpStatus.I_AM_A_TEAPOT).build();
    } () ResponseEntity<Mono<Task>> put( Task task) { (service.isValid(task)) { ResponseEntity.ok( .service.updateTask(task));
        } ResponseEntity.status(HttpStatus.I_AM_A_TEAPOT).build();
    } () ResponseEntity<Mono<Void>> delete( id) { (id > ) { ResponseEntity.ok( .service.deleteTask(id));
        } ResponseEntity.status(HttpStatus.I_AM_A_TEAPOT).build();
    }
} package import import import import import import import import import import import import import import import @RestController @RequestMapping "/api/tasks" public class TasksController @Autowired private @GetMapping public return this @PostMapping public @RequestBody if return this return @PutMapping public @RequestBody if return this return @DeleteMapping public @RequestParam int if 0 return this return Testing it out Now that everything has been constructed, it's time to test it out! First, build the application. $ mvn package And then run it. $ mvn spring-boot:run First, start by adding a new task to your to do list. $ curl --header \
  --request POST \
  --data '{ : }' \
  http://localhost: /api/tasks "Content-Type: application/json" "description" "A New Task" 8080 While you can certainly query the database directly to confirm that a new task record has been added, where's the fun in that? Back to the API! $ curl https://localhost:8080/api/tasks If all goes well you should receive the following JSON response: { : , : , : } "id" 1 "description" "A New Task" "completed" false Voilà, a fully reactive Java Spring application using R2DBC and MariaDb! To view this code in its entirety check out the source . And if you're wondering "it'd sure be nice to see an implementation with a user interface", you're in luck! You can find a fully fleshed out implementation of a TODO application using React.js and your choice of multiple API projects (R2DBC, JDBC, Node.js and Python) that integrate directly with MariaDB ! here here Just getting started Now that you've successfully created a new Maven project using Spring Data, R2DBC and MariaDB, you have all the tools you need to get started creating fully reactive applications, utilizing the power of MariaDB, of your own! If you have any questions, suggestions or concerns with this blog post please let me know here or reach out to me directly on Twitter at ! @probablyrealrob Thanks for taking the time to read this and happy coding!

Reactive Programming with Java Spring, R2DBC and MariaDB

Your head hits the pillow after a long day and instead of effortlessly drifting off to sleep, you find yourself staring at the ceiling not able to fall asleep. Or worse, you close your eyes only to open them frequently to check the clock. Clinical studies show that 40% of the population has trouble sleeping. I know for myself, it typically takes about 30 minutes to fall asleep. Now and then it is restless sleep. When I was younger, from about my teens to thirties, it would take me more than two hours to fall asleep. As an adult, I discovered I had weight ­related sleep apnea and had reached an unhealthy level where good sleep became a problem for me. Additionally, my years of sleep issues (compounded with genetics) recently resulted in a near fatal heart attack. This led me to thoroughly research the topic and share the facts with you in this article. Strange as it may sound, sleep is a very active process and it is more than the absence of wakefulness. It involves a complex physiological, psychological and behavioral states coordinated by your nerve cells (neurons) and brain chemicals (neurotransmitters). This is regulated by your central nervous system. Every organ in the body is affected by the quality your sleep. 5 Stages of Sleep To break it down even more, human sleep is characterized by five stages: Very shallow, superficial sleep. Eyes move slowly and little muscle activity occurs. Stage 1 sleep is fragmented and waking up occurs easily. It is not restorative or refreshing. Stage 1: Usually the longest stage of sleep. Eye movements slow down but awakening can still occur easily. Older individuals and those with chronic illness may spend most of the night in stage 2 sleep. Stage 2: The beginning of slow wave sleep. Many of the body’s repair processes occur during this deeper stage of sleep. It is more difficult to wake up and awakening may result in a confused, disoriented feeling. Stage 3: The deepest stage of Non REM sleep. Neurotransmitters and growth hormones are synthesized. Slow wave sleep is most prominent and intense during childhood and declines sharply at puberty and then slowly across the second and third decades of life. Stage 4: (Rapid Eye Movement) ­Most dreaming occurs in this stage. Breathing becomes more shallow. Rapid and irregular blood pressure and pulse rise, oxygen consumption increases and blood flow to the brain increases. Eyes move in a jerking manner, but muscle paralysis occurs in the extremities (to prevent acting out of dreams or nightmare). Stage 5 or REM: I was most interested in the relationship between sleep and heart disease. I found good research from Norway that suggests a strong link between insomnia and an increased risk of heart failure. This got my attention. During heart failure, the heart stops pumping enough blood around the body at the correct pressure. This is usually due to a weakened heart muscle or stiffness of the arteries that impairs the ability of the heart to work effectively. The Norway research is an examining insomnia and cardiovascular risk factors in more than 54,000 men and women aged 20­-89, who were free of heart failure at the beginning of the study. The results showed that those who reported insomnia symptoms suffered a threefold increased risk for heart failure, compared with those individuals who had no insomnia symptoms. This was the case even after adjustments for factors such as age, sex, marital status, tobacco and alcohol use, depression and anxiety. 11 ­year study Researchers concluded that difficulty falling asleep or maintaining sleep increased the risk of developing and/or dying from cardiovascular disease. Unhealthy Habits Below are some typical habits that cause problems with sleep include: Stress and excessive worry Limited exercise or inactivity Erratic sleep schedule Overeating and indigestion Excessive Alcohol, Caffeine and/or Nicotine Late afternoon napping (after 3pm) Bedroom disruptors: bright light, noise, temperature, television Overuse of sleep medications and/or other prescription drugs Norwegian researcher Dr. Borge Sversten, a professor of clinical psychology at the University of Bergen, noted in his research that sleep problems have become an economic nightmare with 253 million sick days being taken per year in the United States alone due to the problem. There is a growing recognition that insomnia and sleep apnea cause both absenteeism and may lead to serious accidents. A Harvard Medical School sleep study conducted in 2011 by researcher Ronald C. Kessler, Ph.D., found that American workers lost about 11 days and roughly $2,280 per year in lost productivity. The study also found that the estimated annual cost of sleep deprivation is over $63 billion in the U.S. A new Australian study found that about 2% of Australia’s GDP is lost due to sick leave caused by various sleep disorders. Aurora Health Care in Wisconsin, for example, had over 2600 employees take part in a 6 week online course for insomnia sufferers in 2012. This was after the managers surmised that sleep deprivation was an issue with their workforce. The follow up surveys and observations by Aurora say that an average of $672 in productivity savings per participant, per year were realized. There are around 90 sleep disorders listed in the International Classification of Sleep Disorders (or ICSD), these break down into four categories: Dyssomnias- A broad category of sleep disorders characterized by either hypersomnia or insomnia. The three major subcategories include intrinsic (i.e., arising from within the body), extrinsic (secondary to environmental conditions or various pathologic conditions), and disturbances of circadian rhythm. As much as 60% of the population suffers from one of these types of dissorders. Parasomnias- A category of sleep disorders that involve abnormal and unnatural movements, behaviors, emotions, perceptions, and dreams in connection with sleep. Most of these are more pronounced in youths and teenagers, with up to 20% of the population suffering from them, but scaling down to about 4% in adults. Medical or psychiatric conditions that may produce sleep disorders such as Pyschosis and mood disorders like Depression and Anxiety. Getting numbers for this is problematic as depression and anxiety can be caused by lack of sleep as opposed to the other way around. Lack of sleep can lead to a lot of psychiatric conditions. Sleeping sickness- a parasitic disease which can be transmitted by the Tsetse fly. The percentage of people getting insufficient rest or sleep from the ages of 18–64 is fairly consistent at around 25% according to the CDC, but the 25–34 group are the worst at nearly 29%. Not surprisingly, according to the same CDC data, people with children or who are obese get less sleep than their counterparts, around 30%. Somewhat surprising is that married couples get better sleep than all other configurations of singles and couples. Sleeping medications (either prescription or over the counter), when taken for long periods of time, become less effective. Also, studies with older individuals indicate that prolonged sleep medication may falsely appear as symptoms of dementia, including slowed and/or slurred speech, impaired thinking and memory problems. Over 20% of non-­chronic insomnia sufferers report yearly bouts of severe sleeping problems when experiencing stressful events, marital difficulty, health problems and problems with children and relatives. Mobile App Remedies With all the health apps and other health-­related technology, I decided to see if could find something helpful on my Android phone. Everything I found was some variation of nature sounds, white noise or monitoring systems that recorded how often I slept or woke up. None of these really helped, but then I ran across a brand new app called . The reason this stood out is because it is designed by two clinical psychologists with behavioral medical specialties. They took a completely different approach. SleepSound This particular app works by pulsing sound and light in a pattern that essentially synchronizes with your brain waves, causing the brain to slow down to the point that you are gently put it into sleep state. When I first tried, it was a very odd sensation. To start I was thinking that pulsing sounds and flashing lights would not calm me down. In fact, it feels strange for the first minute or two and then suddenly my brain started to relax. All I know is that I was asleep in what seemed to be a much shorter period of time than usual. The app has a configurable start and end pulse rate, as well as a session duration in case you take longer or shorter to get to sleep. The adjustable start rate is important as you could be more or less alert when you start. I tried a higher rate and was getting agitated, so according to the instructions, I lowered the start rate. Another nice feature if you’re prone to waking up is that you can use the app again and adjust the time and pulse rate until you are able to get back to sleep. The app also allowed for background sounds like ocean and wind chimes or no sound at all. I was getting fairly desperate for a better way to fall asleep and I found it.

Stories, News & Mentions about TSET

Tset’s Stories on HackerNoon

Tset's News & Mentions