tset is an innovative company on the intersection of the highly-competitive automotive industry and modern machine learning

tset

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

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

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

Since being back in 2009, has become one of the most popular databases of choice for developers over the past decade. While many technologists have likely gravitated to it as a solution due to its open source roots and that it's rooted in the relational database world, that really only begins to scratch the surface of what MariaDB has to offer. forked from MySQL MariaDB Over the years MariaDB has diverged from MySQL by adding many features and functionality, much of which we won't be able to dive into within the context of this article. However, one thing, above all else, has remained the same; providing a modern, open-source, high quality database solution that developers can use to power their innovation. But before you can dive into MariaDB and check out all it has to offer you'll need to answer the most fundamental of questions; how do you get started using MariaDB? MariaDB and Java Database Connectivity ( ) JDBC It likely comes as no surprise that , and ultimately the environment as a whole, has been an extremely popular option used by developers to create applications. Java Java Virtual Machine (JVM) With that in mind, I've written this short walkthrough to take you through the steps for getting started with using a image, ava and the . MariaDB (Community Server) Docker J MariaDB JDBC client In this walkthrough you'll be utilizing MariaDB and JDBC to create a simple ( based) "To do" application that, using , will expose a variety of endpoints to use to perform basic CRUD (create-read-update-delete) operations on a MariaDB database instance. Maven Java Spring Let's get started! 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 Creating a new MariaDB instance using Docker One of the simplest ways to get started with MariaDB, regardless of which operating system you're using, is to pull the Docker , from Docker Hub, and use it create a new container. MariaDB Server image To do this simply open a terminal window and run the following: $ docker run -p 3306:3306 -d --name mariadb -eMARIADB_ROOT_PASSWORD=Password123! mariadb/server:10.4 That's it. You should now have a running instance of MariaDB. Pretty painless, right? You can confirm the instance within a Docker container by running the following: $ docker ps And you should see your container within the output. Connecting to MariaDB Now that you've got a running MariaDB Server instance within a new Docker container the next step will be to connect to and communicate with the database instance 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: $ mariadb --host 127.0.0.1 -P 3306 --user root -pPassword123! You should see something like the following, which means you've successfully connected to the MariaDB instance! Once you're connected you can create a new database. todo; CREATE DATABASE Then create a new table. todo.tasks ( ( ) AUTO_INCREMENT,
  description ( ) ,
  completed ,
  PRIMARY ( )
); CREATE TABLE id INT 11 unsigned NOT NULL VARCHAR 500 NOT NULL BOOLEAN NOT NULL DEFAULT 0 KEY id Getting Started with Java Spring, JDBC and MariaDB With a database instance spun up and schema created you're ready to create a new application. Java Create a Maven project Start by navigating to , which will enable you to create a new -based project. For this project you can enter the following criteria. https://start.spring.io Spring Maven Next, add the following dependencies: : A library that will eliminate having to create boiler plate code (e.g. getters, setters) within the domain objects. Lombok : A library to create and expose RESTful API endpoints. Spring Web : A library that provides abstractions to help eliminate boiler plate code for connecting to and communicating with databases. Spring Data JPA 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 JDBC connector to the collection of dependencies. <dependency> <artifactId>mariadb-java-client< version> org.mariadb.jdbc < > groupId </ > groupId /artifactId>
   <version>2.6.0</ </ > dependency Preparing the data integration Now that you've created a project that contains all of the dependencies you'll need, it's to jump into the Java code. Typically, I like to start by creating the entity classes. Navigate to , create a new folder called "domain", and create a new file within it named "Task.java". /src/main/java/com/mariadb/todo Open "Task.java" and add the following code. com.mariadb.todo.domain; javax.persistence.*; lombok.Data; (name = ) { (strategy = GenerationType.IDENTITY) Integer id; String description; Boolean completed = ;
} package import import @Data @Entity @Table "tasks" public class Task @Id @GeneratedValue private private private false Next, create a new folder called "repositories" in , and create a new filed within it named "TaskRepository.java". /src/main/java/com/mariadb/todo Open "TaskRepository.java" and add the following code. com.mariadb.todo.repositories; com.mariadb.todo.domain.Task; org.springframework.data.repository.CrudRepository; {
} package import import public < , > interface TaskRepository extends CrudRepository Task Integer Like the name suggests the interface provides basic CRUD operations on a repository for a generic type (your Task class in this case) and the primary key type for that generic type. CrudRepository Create a data service Services can be used to manage the business logic of your application. The only service, TaskService, in this application is used for validating a Task object and integrating with the TaskRepository. Create a new folder called "services" in , and create a new filed within it named "TaskService.java". /src/main/java/com/mariadb/todo Open "TaskService.java" and add the following code. com.mariadb.todo.services; java.util.Optional; com.mariadb.todo.domain.Task; com.mariadb.todo.repositories.TaskRepository; org.springframework.beans.factory.annotation.Autowired; org.springframework.stereotype.Service; org.springframework.transaction.annotation.Transactional; { TaskRepository repository; { (task != && !task.getDescription().isEmpty()) { ;
        } ;
    } { .repository.findAll();
    } { .repository.save(task);
    } {
        Optional<Task> ot = .repository.findById(task.getId());
        Task t = ot.get();
        t.setDescription(task.getDescription());
        t.setCompleted(task.getCompleted()); .repository.save(t);
    } {
        Optional<Task> ot = .repository.findById(id);
        Task t = ot.get(); .repository.delete(t);
    }
} package 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 Iterable<Task> public getAllTasks () return this // Save a new task record Task public createTask ( Task task) final return this // Update an existing task record @Transactional Task public updateTask ( Task task) final this return this // Delete the task record by specified id @Transactional public void deleteTask ( id) final int this this Expose API endpoints Finally, you'll need to create a to expose four endpoints that can be used to perform the basic CRUD operations on your Tasks. controller Create a new folder called "controllers" in , and create a new filed within it named "TaskController.java". /src/main/java/com/mariadb/todo Open "TaskController.java" and add the following code. com.mariadb.todo.controllers; com.mariadb.todo.domain.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; ( ) { TaskService service; () ResponseEntity<Iterable<Task>> get() { ResponseEntity.ok( .service.getAllTasks());
    } () { (service.isValid(task)) { ResponseEntity.ok( .service.createTask(task));
        } ResponseEntity.status(HttpStatus.I_AM_A_TEAPOT).build();
    } () { (service.isValid(task)) { ResponseEntity.ok( .service.updateTask(task));
        } ResponseEntity.status(HttpStatus.I_AM_A_TEAPOT).build();
    } () { (id > ) { .service.deleteTask(id); ResponseEntity.ok().build();
        } ResponseEntity.status(HttpStatus.I_AM_A_TEAPOT).build();
    }
} package import import import import import import import import import import import import import @RestController @RequestMapping "/api/tasks" public class TaskController @Autowired private // Get all tasks @GetMapping public return this // Create a new task @PostMapping ResponseEntity<Task> public post (@RequestBody Task task) if return this return // Update a task @PutMapping ResponseEntity<Task> public put (@RequestBody Task task) if return this return // Delete a task @DeleteMapping ResponseEntity<Void> public delete (@RequestParam id) int if 0 this return 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: "Content-Type: application/json" '{"description":"A New Task"}' //localhost:8080/api/tasks 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 JDBC 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 and your choice of multiple API projects (R2DBC, JDBC, Node.js and Python) that integrate directly with MariaDB ! here React.js here Just getting started Now that you've successfully created a new Maven project using Spring Data JPA, JDBC 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 !Thanks for taking the time to read this and happy coding! @probablyrealrob

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.

Is Your Career Suffering Because of a Sleep Disorder?

Additional performance comparisons available in an updated post . Come see me speak about JSON and XML at SQL Saturday Columbus on July 22 ! Starting with the 2016 release, SQL Server offers native JSON support. Although the implementation is not perfect, . I am still a huge fan Even if a new feature like JSON support is awesome, I am only likely to use it if it is practical and performs better than the alternatives. Today I want to pit JSON against XML and see which is the better format to use in SQL Server. Enter XML, SQL’s Bad Hombre Full disclosure: I don’t love XML and I also don’t love SQL Server’s implementation of it. XML is too wordy (lots of characters wasted on closing tags), it has elements AND attributes (I don’t like having to program for two different scenarios), and depending on what language you are in, sometimes you need schema files and sometimes you don’t. programming SQL Server’s implementation of XML does have some nice features like a dedicated datatype that reduces storage space and validates syntax, but I find the querying of XML to be clumsy. All XML grievances aside, I am still willing to use XML if it outperforms JSON. So let’s run some test queries! Is JSON SQL Server’s New Sheriff in Town? Although performance is the final decider in these comparison tests, I think JSON has a head start over XML purely in terms of usability. SQL Server’s JSON function signatures are easier to remember and cleaner to write on screen. The test data I’m using is vehicle year/make/model data from . Here’s what it looks like once I loaded it into a table called : https://github.com/arthurkao/vehicle-make-model-data dbo.XmlVsJson CREATE TABLE dbo.XmlVsJson(Id INT IDENTITY PRIMARY KEY,XmlData XML,JsonData NVARCHAR(MAX)) ( if you want to play along at home) The full data query is available in this gist Data Size So XML should be larger right? It’s got all of those repetitive closing tags? SELECTDATALENGTH(XmlData)/1024.0/1024.0 AS XmlMB,DATALENGTH(JsonData)/1024.0/1024.0 AS JsonMBFROMdbo.XmlVsJson Turns out the XML is actually smaller! How can this be? This is the magic behind the . SQL doesn’t store XML as a giant string; it stores only the , leading to a reduction in space. SQL Server XML datatype XML InfoSet The JSON on the other hand is stored as regular old nvarchar(max) so its full string contents are written to disk. XML wins in this case. INSERT Performance So XML is physically storing less data when using the XML data type than JSON in the nvarchar(max) data type, does that mean it will insert faster as well? Here’s our query that tries to insert 100 duplicates of the row from our first query: SET STATISTICS TIME ON INSERT INTO dbo.XmlVsJson (XmlData)SELECT XmlData FROM dbo.XmlVsJsonCROSS APPLY(SELECT DISTINCT numberFROM master..spt_valuesWHERE number BETWEEN 1 AND 100)t WHERE Id = 1GO INSERT INTO dbo.XmlVsJson (JsonData)SELECT JsonData FROM dbo.XmlVsJsonCROSS APPLY(SELECT DISTINCT numberFROM master..spt_valuesWHERE number BETWEEN 1 AND 100)t WHERE Id = 1GO And the results? Inserting the 100 XML rows took 613ms on my machine, while inserting the 100 JSON rows took 1305ms… XML wins again! JSON ain’t looking too hot. Wait for it… I’m guessing since the XML data type physically stores less data, it makes sense that it would also write it out to the table faster as well. CRUD Operations — but how does it compare to XML on ? I’m incredibly impressed by SQL Server’s JSON performance when compared to .NET SQL Server Read Let’s select the fragment for our second car from our XML and JSON: SELECT t.XmlData.query('/cars/car[2]')FROM dbo.XmlVsJson tWHERE Id = 1 SELECT JSON_QUERY(t.JsonData, '$.cars[1]')FROM dbo.XmlVsJson tWHERE Id = 1 Result? (at 0ms vs 63ms for XML) when needing to pluck out a fragment from our larger object string. JSON wins What if we want to grab a specific value instead of a fragment? SELECT t.XmlData.value('(/cars/car[2]/model)[1]', 'varchar(100)') FROM dbo.XmlVsJson tWHERE Id = 1 SELECT JSON_VALUE(t.JsonData, '$.cars[1].model')FROM dbo.XmlVsJson tWHERE Id = 1 Once again with 0ms vs 11ms for XML. JSON wins If you look at the execution plans for these last two queries, it’s easy to see that XML has a lot more to do behind the scenes to retrieve the data: XML: JSON: Create We saw above that inserting rows of XML data is faster than inserting rows of JSON, but what if we want to insert new data into the object strings themselves? Here I want to insert the property “mileage” into the first car object: UPDATE t SET XmlData.modify('insert <mileage>100,000</mileage>into (/cars/car[1])[1]')FROM dbo.XmlVsJson tWHERE Id = 1 UPDATE t SET JsonData = JSON_MODIFY(JsonData,'$.cars[0].mileage','100,000')FROM dbo.XmlVsJson tWHERE Id = 1 In addition to the cleaner syntax ( is essentially the same as a ) the JSON insert runs in 22ms compared to the 206ms for XML. JSON_MODIFY() REPLACE() Another JSON win. Update Let’s update the mileage properties we just added to have values of 110,000: UPDATE t SET XmlData.modify('replace value of (/cars/car[1]/mileage/text())[1]with     "110,000"')FROM dbo.XmlVsJson tWHERE Id = 1 UPDATE t SET JsonData = JSON_MODIFY(JsonData, '$.cars[0].mileage','110,000')FROM dbo.XmlVsJson tWHERE Id = 1 Result? and was able to perform this update in 54ms vs XML’s 194ms. JSON has the quicker draw Delete Deleting large string data, a DBA’s dream *snicker*. Let’s delete the mileage property, undoing all of that hard work we just did: UPDATE t SET XmlData.modify('delete /cars/car[1]/mileage[1]')FROM dbo.XmlVsJson tWHERE Id = 1 UPDATE t SET JsonData = JSON_MODIFY(JsonData, '$.cars[0].mileage', null)FROM dbo.XmlVsJson tWHERE Id = 1 50ms to 159ms. JSON doesn’t take any time to reload and wins against XML again Read Part 2: Indexes So above we saw that JSON was faster than XML at reading fragments and properties from a single row of serialized data. But our SQL Server’s probably have LOTS of rows of data — how well does indexed data parsing do in our match up? First let’s expand our data — instead of storing all of our car objects in a single field, let’s build a new table that has each car on its own row: (once again, if you are playing along at home) full dataset at GitHub Now that we have our expanded data in our table, let’s add some indexes. The XML datatype in SQL Server has its own types of indexes, while . JSON simply needs a computed column with a regular index applied to it DROP INDEX IF EXISTS PXML_XmlData ON XmlVsJson2CREATE PRIMARY XML INDEX PXML_XmlDataON XmlVsJson2 (XmlData); ALTER TABLE dbo.XmlVsJson2ADD MakeComputed AS JSON_VALUE(JsonData, '$.make')CREATE NONCLUSTERED INDEX IX_JsonData ON dbo.XmlVsJson2 (MakeComputed) (Note: I also tried adding an XML secondary index for even better performance, but I couldn’t get the query engine to use that secondary index on such a basic dataset) If we try to find all rows that match a predicate: SELECT Id, XmlDataFROM dbo.XmlVsJson2 tWHERE t.XmlData.exist('/car/make[.="ACURA"]') = 1 SELECT Id, JsonDataFROM dbo.XmlVsJson2 tWHERE JSON_VALUE(t.JsonData, '$.make') = 'ACURA' XML is able to filter out 96 rows in 200ms and JSON accomplishes the same in 9ms. . A final win for JSON Conclusion If you need to store and manipulate serialized string data in SQL Server, there’s no question: JSON is the format of choice. Although JSON’s storage size is a little larger than its XML predecessor, SQL Server’s JSON functions outperform XML in speed in nearly all cases. Is there enough performance difference to rewrite all of your old XML code to JSON? Probably not, but every case is different. One thing is clear: new development should consider taking advantage of SQL Server’s new JSON functions. 💚 Enjoyed this post? Please recommend it by giving it a green heart below. Do you still plan on using XML instead of JSON for new development in SQL Server 2016+? I’d be curious to know why in the comments below.

XML vs JSON Shootout: Which Should I Use in SQL Server?

Writing Effective Integration Tests in Spring: Organized Testing Strategies for HTTP Request Mocking

It’s been a while since we’ve seen some serious FUD on USDT. Recently, Ripple CEO Brad Garlinghouse said that the U.S. government was going after Tether, which issues the USDT stablecoin. He did not provide any specific thoughts on possible risks to the USDT stablecoin. At the same time, Brad Garlinghouse noted that USDT was important for the entire crypto ecosystem and the story was worth monitoring. In response, Tether noted that Ripple would soon launch its own stablecoin. According to Tether, Brad Garlinghouse was simply trying to put some pressure on the competitor's product. However, it is quite possible that Ripple CEO had some specific threats in mind when talking about USDT-related risks. According to recent reports, the U.S. was working on rules that would limit issuers without a banking license to a maximum stablecoin market cap of $10 billion. Such rules would prohibit U.S. entities from holding and transacting with offshore-issued stablecoins that do not have a U.S. banking license, such as USDT. In theory, the potential rules will provide banks with an opportunity to create their own stablecoins and compete with USDT. It’s no secret that U.S. regulators do not like the offshore Tether, although the company has boosted its compliance with U.S. rules, including sanctions. With a market cap exceeding $110 billion, USDT is the dominant force in the stablecoin market. The second biggest stablecoin, USDC, has a market cap of roughly $33 billion. Put simply, the market is choosing USDT over USDC. At this point, USDC is the go-to stablecoin for anyone who wants a U.S.-based stablecoin. Ironically, USDC suffered from its U.S. exposure back in March 2023, when the U.S. regional banks crisis dealt a serious blow to its capitalization. The data shows that there is no demand for another U.S.-focused stablecoin. PayPal, which aimed to leverage its huge user base, tried to promote its own stablecoin, PYUSD. The result is extremely disappointing since PYUSD failed to climb above the $400 million market cap level. It remains to be seen whether Ripple’s stablecoin will gain market success. It should be noted that USDT is used all over the world. For many users, its offshore nature is a feature, not a bug. It is not clear whether such users would like to deal with a potential stablecoin issued by a big U.S. bank. In addition, crypto markets are growing fast, which means that the potential total market cap for all existing stablecoins is growing as well. Thus, USDT may lose market share to a U.S. bank-issued stablecoin but still increase its market cap due to rising demand for stablecoins in the world. Bottom line: USDT is well positioned to profit from crypto market growth. Real market data shows that demand for U.S.-based stablecoins is weaker than for offshore-based stablecoins. The proposed U.S. rules could put some pressure on USDT market share but will not serve as the black swan event for crypto markets or USDT itself. It’s been a while since we’ve seen some serious FUD on USDT. Recently, Ripple CEO Brad Garlinghouse said that the U.S. government was going after Tether, which issues the USDT stablecoin. said said He did not provide any specific thoughts on possible risks to the USDT stablecoin. At the same time, Brad Garlinghouse noted that USDT was important for the entire crypto ecosystem and the story was worth monitoring. In response, Tether noted that Ripple would soon launch its own stablecoin. According to Tether, Brad Garlinghouse was simply trying to put some pressure on the competitor's product. However, it is quite possible that Ripple CEO had some specific threats in mind when talking about USDT-related risks. noted noted According to recent reports , the U.S. was working on rules that would limit issuers without a banking license to a maximum stablecoin market cap of $10 billion. Such rules would prohibit U.S. entities from holding and transacting with offshore-issued stablecoins that do not have a U.S. banking license, such as USDT. In theory, the potential rules will provide banks with an opportunity to create their own stablecoins and compete with USDT. reports reports It’s no secret that U.S. regulators do not like the offshore Tether, although the company has boosted its compliance with U.S. rules, including sanctions. With a market cap exceeding $110 billion, USDT is the dominant force in the stablecoin market. The second biggest stablecoin, USDC, has a market cap of roughly $33 billion. Put simply, the market is choosing USDT over USDC. At this point, USDC is the go-to stablecoin for anyone who wants a U.S.-based stablecoin. Ironically, USDC suffered from its U.S. exposure back in March 2023, when the U.S. regional banks crisis dealt a serious blow to its capitalization. The data shows that there is no demand for another U.S.-focused stablecoin. PayPal, which aimed to leverage its huge user base, tried to promote its own stablecoin, PYUSD. The result is extremely disappointing since PYUSD failed to climb above the $400 million market cap level. It remains to be seen whether Ripple’s stablecoin will gain market success. It should be noted that USDT is used all over the world. For many users, its offshore nature is a feature, not a bug. It is not clear whether such users would like to deal with a potential stablecoin issued by a big U.S. bank. In addition, crypto markets are growing fast, which means that the potential total market cap for all existing stablecoins is growing as well. Thus, USDT may lose market share to a U.S. bank-issued stablecoin but still increase its market cap due to rising demand for stablecoins in the world. Bottom line: USDT is well positioned to profit from crypto market growth. Real market data shows that demand for U.S.-based stablecoins is weaker than for offshore-based stablecoins. The proposed U.S. rules could put some pressure on USDT market share but will not serve as the black swan event for crypto markets or USDT itself.

Ripple CEO Talks About the U.S. Government Going After Tether: Is It Just Another FUD?

Testing LLMs on Solving Leetcode Problems

Dear ZKBase Community, The ZKBase team is excited to announce the detailed product roadmap on May 9th, 2024. ZKBase is a decentralized, GPU-based, programmable ZKEVM chain. Our goal is to provide a stable and efficient decentralized platform to support a wide range of DApp development and smart contract operations. Product Planning Phase One: Testnet ZKBase plans to launch the testnet on the 21st of May, 2024, with full browser functionality and DEX use cases (Swap and Liquidity Pool). Users will be able to thoroughly test these features using test tokens. Phase Two: Mainnet Launch Mainnet will support — Wallet Integration: Users can easily add the network to existing wallets like MetaMask without needing to create a separate Layer2 wallet.


Blockchain Explorer: Supports various types of smart contract operations. DApp Support — DEX: Offering a full set of ZKSwap feature use cases.


We plan to officially launch the mainnet around June 12th, 2024.


Additionally, we have updated the community media logos to align with the ZKBase chain launch.


ZKMarket (Decentralized Computing Power Market) We will create a public decentralized computing power market. This platform will encourage more power providers to participate in mining and establish an open and free environment for interaction between computing power providers and consumers. This not only provides a new mode for trading computing resources but also ensures the transparency, security, and automation of transactions. Features in Planning — Additional DApps are still in the planning stages, with specific launch timelines to be determined. Timeline Testnet Development: From April 15th to May 31st, complete product design and development work, ensuring the testnet launches around May 21st, 2024.
Testnet Operation and Mainnet Preparation: From June 1 to June 15, running the testnet and preparing for the mainnet.
Mainnet Release: Expected to officially release in mid-June. Future Plans Technology Enhancement: Continue researching the development of Ethereum Layer 2 chain technology to ensure timely updates and advancements.


Integration Support: Provide support to encourage developers to quickly build and deploy applications based on ZKBase.


Community Building: Establish a developer community for technical support and resource sharing to promote cooperation and communication.


Partnership Development: Establish partnerships within the Ethereum ecosystem and expand cross-chain cooperation to enrich the blockchain ecosystem.


Promotion and Marketing: Launch comprehensive promotional activities to educate users and developers about the advantages and application scenarios of ZKBase technology, driving its widespread adoption. Thank you all for your ongoing support and participation. Let us look forward to the new experiences and possibilities that ZKBase will bring! ZKBase Team Dear ZKBase Community, The ZKBase team is excited to announce the detailed product roadmap on May 9th, 2024. ZKBase is a decentralized, GPU-based, programmable ZKEVM chain. Our goal is to provide a stable and efficient decentralized platform to support a wide range of DApp development and smart contract operations. Product Planning Phase One: Testnet ZKBase plans to launch the testnet on the 21st of May, 2024, with full browser functionality and DEX use cases (Swap and Liquidity Pool). Users will be able to thoroughly test these features using test tokens. DEX Phase Two: Mainnet Launch Mainnet will support — Wallet Integration: Users can easily add the network to existing wallets like MetaMask without needing to create a separate Layer2 wallet. Blockchain Explorer: Supports various types of smart contract operations. Wallet Integration: Users can easily add the network to existing wallets like MetaMask without needing to create a separate Layer2 wallet. Wallet Integration : Users can easily add the network to existing wallets like MetaMask without needing to create a separate Layer2 wallet. Wallet Integration Blockchain Explorer: Supports various types of smart contract operations. Blockchain Explorer : Supports various types of smart contract operations. Blockchain Explorer DApp Support — DEX: Offering a full set of ZKSwap feature use cases. We plan to officially launch the mainnet around June 12th, 2024. Additionally, we have updated the community media logos to align with the ZKBase chain launch. ZKMarket (Decentralized Computing Power Market) DEX: Offering a full set of ZKSwap feature use cases. DEX : Offering a full set of ZKSwap feature use cases. DEX We plan to officially launch the mainnet around June 12th, 2024. We plan to officially launch the mainnet around June 12th, 2024. Additionally, we have updated the community media logos to align with the ZKBase chain launch. Additionally, we have updated the community media logos to align with the ZKBase chain launch. ZKMarket (Decentralized Computing Power Market) ZKMarket (Decentralized Computing Power Market) We will create a public decentralized computing power market. This platform will encourage more power providers to participate in mining and establish an open and free environment for interaction between computing power providers and consumers. This not only provides a new mode for trading computing resources but also ensures the transparency, security, and automation of transactions. Features in Planning — Additional DApps are still in the planning stages, with specific launch timelines to be determined. Additional DApps are still in the planning stages, with specific launch timelines to be determined. Timeline Testnet Development: From April 15th to May 31st, complete product design and development work, ensuring the testnet launches around May 21st, 2024. Testnet Operation and Mainnet Preparation: From June 1 to June 15, running the testnet and preparing for the mainnet. Mainnet Release: Expected to officially release in mid-June. Testnet Development: From April 15th to May 31st, complete product design and development work, ensuring the testnet launches around May 21st, 2024. Testnet Operation and Mainnet Preparation: From June 1 to June 15, running the testnet and preparing for the mainnet. Mainnet Release: Expected to officially release in mid-June. Future Plans Technology Enhancement: Continue researching the development of Ethereum Layer 2 chain technology to ensure timely updates and advancements. Integration Support: Provide support to encourage developers to quickly build and deploy applications based on ZKBase. Community Building: Establish a developer community for technical support and resource sharing to promote cooperation and communication. Partnership Development: Establish partnerships within the Ethereum ecosystem and expand cross-chain cooperation to enrich the blockchain ecosystem. Promotion and Marketing: Launch comprehensive promotional activities to educate users and developers about the advantages and application scenarios of ZKBase technology, driving its widespread adoption. Technology Enhancement: Continue researching the development of Ethereum Layer 2 chain technology to ensure timely updates and advancements. Technology Enhancement : Continue researching the development of Ethereum Layer 2 chain technology to ensure timely updates and advancements. Technology Enhancement Integration Support: Provide support to encourage developers to quickly build and deploy applications based on ZKBase. Integration Support : Provide support to encourage developers to quickly build and deploy applications based on ZKBase. Integration Support Community Building: Establish a developer community for technical support and resource sharing to promote cooperation and communication. Community Building : Establish a developer community for technical support and resource sharing to promote cooperation and communication. Community Building Partnership Development: Establish partnerships within the Ethereum ecosystem and expand cross-chain cooperation to enrich the blockchain ecosystem. Partnership Development : Establish partnerships within the Ethereum ecosystem and expand cross-chain cooperation to enrich the blockchain ecosystem. Partnership Development Promotion and Marketing: Launch comprehensive promotional activities to educate users and developers about the advantages and application scenarios of ZKBase technology, driving its widespread adoption. Promotion and Marketing : Launch comprehensive promotional activities to educate users and developers about the advantages and application scenarios of ZKBase technology, driving its widespread adoption. Promotion and Marketing Thank you all for your ongoing support and participation. Let us look forward to the new experiences and possibilities that ZKBase will bring! ZKBase Team ZKBase Team

ZKBase Unveils Detailed Product Roadmap: Testnet Launch, Mainnet Integration and Beyond 

ZKBase বিস্তারিত পণ্য রোডম্যাপ উন্মোচন করেছে: টেস্টনেট লঞ্চ, মেইননেট ইন্টিগ্রেশন এবং এর বাইরে

ZKBase stellt detaillierte Produkt-Roadmap vor: Testnet-Start, Mainnet-Integration und mehr

ZKBase presenta una hoja de ruta detallada del producto: lanzamiento de Testnet, integración de Mainnet y más

ZKBase dévoile une feuille de route détaillée du produit : lancement de Testnet, intégration du réseau principal et au-delà

ZKBase ने विस्तृत उत्पाद रोडमैप का अनावरण किया: टेस्टनेट लॉन्च, मेननेट एकीकरण और उससे आगे

ZKBase が詳細な製品ロードマップを発表: テストネットの立ち上げ、メインネットの統合など

ZKBase, 상세한 제품 로드맵 공개: 테스트넷 출시, 메인넷 통합 및 그 이상

ZKBase revela roteiro detalhado do produto: lançamento de testnet, integração de mainnet e muito mais

ZKBase представляет подробный план развития продукта: запуск тестовой сети, интеграция с основной сетью и многое другое

ZKBase Ayrıntılı Ürün Yol Haritasını Açıkladı: Testnet Lansmanı, Ana Ağ Entegrasyonu ve Ötesi

ZKBase tiết lộ lộ trình sản phẩm chi tiết: Khởi chạy Testnet, tích hợp Mainnet và hơn thế nữa

ZKBase 公布详细产品路线图：测试网发布、主网集成及其他

LONDON, UK, May 10th, 2024/Chainwire/--Kintsu, a leading innovator in the DeFi space, is thrilled to announce the launch of its highly anticipated Testnet on May 13th. This exclusive event invites a select group, including the Kintsu OGs, to pioneer a new era in liquid staking on the cutting-edge Aleph Zero blockchain. Aleph Zero is a permissionless Layer-1 blockchain that combines a Proof of Stake (PoS) consensus mechanism with a Directed Acyclic Graph (DAG) for scalability, security, and efficiency. Its advanced privacy features include zero-knowledge proofs (ZK-SNARKs) and secure multi-party computation (sMPC) within the Liminal privacy layer. About Kintsu Kintsu aims to reshape the DeFi landscape with its next-generation liquid staking platform, empowering users to stake their assets while maintaining liquidity. By leveraging Aleph Zero’s state-of-the-art security and unparalleled transaction speeds, Kintsu provides unmatched flexibility and efficiency in liquid staking. A recipient of the Aleph Zero Ecosystem Funding Program, Kintsu is recognized as a pioneer within the Aleph Zero, INK, and Substrate ecosystem. With a focus on decentralization, and security, Kintsu aims to redefine liquid staking, providing DeFi users with a efficient, scalable, liquid, and composable staking solution. Key Features of the Kintsu Testnet Exclusive Early Access: A select group, including the Kintsu OGs, will have the opportunity to participate first, offering focused feedback to enhance the platform iteratively.
Seamless Staking Process: Users can stake their tokens with ease and have them allocated among carefully selected validators for optimal security and efficiency.
Innovative Unstaking and Batching Process: Unstaking requests are collected over a 48-hour period before being batched, followed by a standard 14-day unbonding period. Participants can cancel their requests until they are batched.
Claimable Gas Rewards: Following the unbonding period, participants can claim gas rewards from the Liquid Staking Tokens (LSTs) initially escrowed.
Comprehensive Wallet Support: Participants can utilize wallets like Aleph Zero Signer, Nightly, Subwallet, Talisman, and Polkadot{.js}. Hats Finance Audit Competition: Kintsu has partnered with Hats Finance, a decentralized cybersecurity network, to conduct an audit competition on the contracts that will be deployed on the Testnet. The competition features a bounty of $40,000, incentivizing ethical hackers and security experts to identify and report vulnerabilities. This initiative ensures that Kintsu's contracts are thoroughly vetted before their mainnet launch, maintaining the highest security standards as Kintsu pioneers the future of liquid staking. Participation and Feedback: Kintsu invites its community to actively participate in the Testnet, exploring its innovative features and providing crucial feedback. This feedback will play a significant role in enhancing the platform's user experience. Connecting with the Kintsu Community Users can stay updated on the latest developments and engage with other like-minded individuals by joining the Kintsu Discord community and following on Twitter. Insights and feedback from the community are crucial in shaping the future of DeFi. Contact Director of Growth Alexios Konstantinidis Kintsu hello@kintsu.xyz This story was distributed as a release by Chainwire under HackerNoon’s Business Blogging Program. Learn more about the program here. LONDON, UK, May 10th, 2024/Chainwire/--Kintsu, a leading innovator in the DeFi space, is thrilled to announce the launch of its highly anticipated Testnet on May 13th. This exclusive event invites a select group, including the Kintsu OGs, to pioneer a new era in liquid staking on the cutting-edge Aleph Zero blockchain. Aleph Zero is a permissionless Layer-1 blockchain that combines a Proof of Stake (PoS) consensus mechanism with a Directed Acyclic Graph (DAG) for scalability, security, and efficiency. Its advanced privacy features include zero-knowledge proofs (ZK-SNARKs) and secure multi-party computation (sMPC) within the Liminal privacy layer. About Kintsu Kintsu aims to reshape the DeFi landscape with its next-generation liquid staking platform, empowering users to stake their assets while maintaining liquidity. By leveraging Aleph Zero’s state-of-the-art security and unparalleled transaction speeds, Kintsu provides unmatched flexibility and efficiency in liquid staking. A recipient of the Aleph Zero Ecosystem Funding Program, Kintsu is recognized as a pioneer within the Aleph Zero, INK, and Substrate ecosystem. With a focus on decentralization, and security, Kintsu aims to redefine liquid staking, providing DeFi users with a efficient, scalable, liquid, and composable staking solution. Key Features of the Kintsu Testnet Exclusive Early Access: A select group, including the Kintsu OGs, will have the opportunity to participate first, offering focused feedback to enhance the platform iteratively. Seamless Staking Process: Users can stake their tokens with ease and have them allocated among carefully selected validators for optimal security and efficiency. Innovative Unstaking and Batching Process: Unstaking requests are collected over a 48-hour period before being batched, followed by a standard 14-day unbonding period. Participants can cancel their requests until they are batched. Claimable Gas Rewards: Following the unbonding period, participants can claim gas rewards from the Liquid Staking Tokens (LSTs) initially escrowed. Comprehensive Wallet Support: Participants can utilize wallets like Aleph Zero Signer, Nightly, Subwallet, Talisman, and Polkadot{.js}. Exclusive Early Access: A select group, including the Kintsu OGs, will have the opportunity to participate first, offering focused feedback to enhance the platform iteratively. Seamless Staking Process: Users can stake their tokens with ease and have them allocated among carefully selected validators for optimal security and efficiency. Innovative Unstaking and Batching Process: Unstaking requests are collected over a 48-hour period before being batched, followed by a standard 14-day unbonding period. Participants can cancel their requests until they are batched. Claimable Gas Rewards: Following the unbonding period, participants can claim gas rewards from the Liquid Staking Tokens (LSTs) initially escrowed. Comprehensive Wallet Support: Participants can utilize wallets like Aleph Zero Signer, Nightly, Subwallet, Talisman, and Polkadot{.js}. Hats Finance Audit Competition: Kintsu has partnered with Hats Finance, a decentralized cybersecurity network, to conduct an audit competition on the contracts that will be deployed on the Testnet. The competition features a bounty of $40,000, incentivizing ethical hackers and security experts to identify and report vulnerabilities. This initiative ensures that Kintsu's contracts are thoroughly vetted before their mainnet launch, maintaining the highest security standards as Kintsu pioneers the future of liquid staking. Participation and Feedback: Kintsu invites its community to actively participate in the Testnet, exploring its innovative features and providing crucial feedback. This feedback will play a significant role in enhancing the platform's user experience. Connecting with the Kintsu Community Users can stay updated on the latest developments and engage with other like-minded individuals by joining the Kintsu Discord community and following on Twitter. Insights and feedback from the community are crucial in shaping the future of DeFi. Contact Director of Growth Alexios Konstantinidis Kintsu hello@kintsu.xyz This story was distributed as a release by Chainwire under HackerNoon’s Business Blogging Program. Learn more about the program here. This story was distributed as a release by Chainwire under HackerNoon’s Business Blogging Program. Learn more about the program here . here here

Experience The Future Of Liquid Staking: Kintsu Testnet Launches Exclusively On May 13th

In my previous article, I delved into the statistical methods to perform causal analysis. One of the methodologies involved using “instrument variables”. We will delve deep into the math of that methodology in this article series. In the first part, we will cover the basics of model specification errors and confounding; and in the second part, we will cover the math behind instrument variables. Regression model specification errors – There are two prominent kinds of regression model specification errors: Specifying the model incorrectly by exclusion of relevant variables
Specifying the model incorrectly by inclusion of irrelevant variables Of course we will have to investigate how these regression model specification errors impact the regression. Before we do that, let’s cover the derivation of a basic result. This proves that the least squares estimator is unbiased. Now, we go back to our earlier discussion on the regression model specification errors. Our objective will be to investigate the bias in the least squares error estimator because of those errors. Now that we have covered the mathematical background of confounding, we are ready to delve deep into the math of instrument variables in the part 2 of this article. In my previous article , I delved into the statistical methods to perform causal analysis. One of the methodologies involved using “instrument variables”. We will delve deep into the math of that methodology in this article series. In the first part, we will cover the basics of model specification errors and confounding; and in the second part, we will cover the math behind instrument variables. Regression model specification errors – There are two prominent kinds of regression model specification errors: previous article Specifying the model incorrectly by exclusion of relevant variables Specifying the model incorrectly by inclusion of irrelevant variables Specifying the model incorrectly by exclusion of relevant variables Specifying the model incorrectly by inclusion of irrelevant variables Of course we will have to investigate how these regression model specification errors impact the regression. Before we do that, let’s cover the derivation of a basic result. This proves that the least squares estimator is unbiased. Now, we go back to our earlier discussion on the regression model specification errors. Our objective will be to investigate the bias in the least squares error estimator because of those errors. Now that we have covered the mathematical background of confounding, we are ready to delve deep into the math of instrument variables in the part 2 of this article.

Instrument Variables and AB Testing – Part 1

Morph, an Ethereum layer 2 leading a Consumer Blockchain revolution, has announced the launch of its latest advancement, its Holesky Testnet. This new development comes on the heels of their successful Morph Sepolia Testnet and introduces a highly anticipated platform that showcases significant improvements in blockchain infrastructure and application. Already known for its commitment to consumer-centric solutions, Morph stands as a unique player in the space by focusing on real-world utility over the often speculative nature of many blockchain applications. Unlike traditional platforms that prioritize DeFi and trading, Morph aims to provide services that people can use daily, making blockchain technology an integral part of everyday life. The launch of the Holesky Testnet with its enhanced capabilities is a crucial step towards realizing this vision, bridging the gap between sophisticated technology and practical, everyday applications. Key Features and Innovations of the Morph Holesky Testnet: Enhanced Performance and Infrastructure The Holesky Testnet operates using Ethereum Holesky as Layer 1, elevating standards for performance and aligning closely with the infrastructure of the anticipated mainnet. This transition promises users a seamless and advanced preview of what to expect with the full launch. Advanced Features EIP-4844 Optimistic zkEVM Integration: This integration significantly reduces transaction costs, making blockchain operations more efficient.
Revamped Bridge Mechanism: The updated bridge mechanism now allows for withdrawals to be finalized in just one transaction, enhancing the user experience.
Robust Decentralized Sequencer Network: With fully decentralized modules and an increased number of sequencers, the network's backbone is stronger than ever, ensuring unparalleled reliability and security. Economic System Innovations The testnet introduces a novel economic model centered around a decentralized sequencer network, positioning Morph to set new market trends and standards. Impact on the Morph Community For testnet users, prior contributions to the Sepolia testnet are well recorded. Users are now encouraged to transition to the Holesky testnet to benefit from lower fees and superior functionality. For developers, Morph recommends migrating contracts from the Sepolia to the Holesky testnet. Detailed guidance on this process can be found here. The explorer is accessible for tracking deployments and interactions at Holesky Testnet Explorer. Engaging with Morph’s New Testnet: Developers new to Morph's platform can quickly get up to speed through the comprehensive documentation available. For those already familiar with the Sepolia testnet, the core steps to engage with Holesky remain consistent. Start by deep diving into Morph's technology on the About Morph Page, then understand the inner workings of Morph’s infrastructure, and start the development journey with a quickstart guide. For more, review comprehensive Developer Documentation to build innovative blockchain applications. Morph invites the global tech community to join in this revolutionary phase. This new testnet is a significant leap towards realizing a consumer-centric blockchain ecosystem that promises to redefine interaction with technology. About Morph Morph is a fully permissionless EVM L2 that uses a combination of optimistic and zero knowledge rollup technology to enable limitless possibilities in finance, gaming, social media, and entertainment. Morph is the first Layer 2 on Ethereum to launch with a decentralized sequencer, aligning it with several core principles of web3 — decentralization, censorship resistance, and security. The blockchain was built with mainstream audiences like gamers and social media users in mind, making it a user-friendly option for developers who require a chain to build these types of apps on. Website | Twitter |Discord | Telegram |Medium｜Linkedin This story was distributed as a release by Btcwire under HackerNoon’s Business Blogging Program. Learn more about the program here. Morph, an Ethereum layer 2 leading a Consumer Blockchain revolution, has announced the launch of its latest advancement, its Holesky Testnet. This new development comes on the heels of their successful Morph Sepolia Testnet and introduces a highly anticipated platform that showcases significant improvements in blockchain infrastructure and application. Already known for its commitment to consumer-centric solutions, Morph stands as a unique player in the space by focusing on real-world utility over the often speculative nature of many blockchain applications. Unlike traditional platforms that prioritize DeFi and trading, Morph aims to provide services that people can use daily, making blockchain technology an integral part of everyday life. The launch of the Holesky Testnet with its enhanced capabilities is a crucial step towards realizing this vision, bridging the gap between sophisticated technology and practical, everyday applications. Key Features and Innovations of the Morph Holesky Testnet: Enhanced Performance and Infrastructure The Holesky Testnet operates using Ethereum Holesky as Layer 1, elevating standards for performance and aligning closely with the infrastructure of the anticipated mainnet. This transition promises users a seamless and advanced preview of what to expect with the full launch. Advanced Features EIP-4844 Optimistic zkEVM Integration: This integration significantly reduces transaction costs, making blockchain operations more efficient. Revamped Bridge Mechanism: The updated bridge mechanism now allows for withdrawals to be finalized in just one transaction, enhancing the user experience. Robust Decentralized Sequencer Network: With fully decentralized modules and an increased number of sequencers, the network's backbone is stronger than ever, ensuring unparalleled reliability and security. EIP-4844 Optimistic zkEVM Integration: This integration significantly reduces transaction costs, making blockchain operations more efficient. Revamped Bridge Mechanism: The updated bridge mechanism now allows for withdrawals to be finalized in just one transaction, enhancing the user experience. Robust Decentralized Sequencer Network: With fully decentralized modules and an increased number of sequencers, the network's backbone is stronger than ever, ensuring unparalleled reliability and security. Economic System Innovations The testnet introduces a novel economic model centered around a decentralized sequencer network, positioning Morph to set new market trends and standards. Impact on the Morph Community For testnet users, prior contributions to the Sepolia testnet are well recorded. Users are now encouraged to transition to the Holesky testnet to benefit from lower fees and superior functionality. For developers, Morph recommends migrating contracts from the Sepolia to the Holesky testnet. Detailed guidance on this process can be found here . The explorer is accessible for tracking deployments and interactions at Holesky Testnet Explorer . here here Holesky Testnet Explorer Holesky Testnet Explorer Engaging with Morph’s New Testnet: Developers new to Morph's platform can quickly get up to speed through the comprehensive documentation available. For those already familiar with the Sepolia testnet , the core steps to engage with Holesky remain consistent. Start by deep diving into Morph's technology on the About Morph Page , then understand the inner workings of Morph’s infrastructure, and start the development journey with a quickstart guide . For more, review comprehensive Developer Documentation to build innovative blockchain applications. Sepolia testnet About Morph Page About Morph Page understand the inner workings understand the inner workings quickstart guide quickstart guide comprehensive Developer Documentation comprehensive Developer Documentation Morph invites the global tech community to join in this revolutionary phase. This new testnet is a significant leap towards realizing a consumer-centric blockchain ecosystem that promises to redefine interaction with technology. About Morph Morph is a fully permissionless EVM L2 that uses a combination of optimistic and zero knowledge rollup technology to enable limitless possibilities in finance, gaming, social media, and entertainment. Morph is the first Layer 2 on Ethereum to launch with a decentralized sequencer, aligning it with several core principles of web3 — decentralization, censorship resistance, and security. The blockchain was built with mainstream audiences like gamers and social media users in mind, making it a user-friendly option for developers who require a chain to build these types of apps on. Website | Twitter |Discord | Telegram |Medium｜Linkedin Website | Twitter | Discord | Telegram | Medium｜ Linkedin Website Website Twitter Twitter Discord Discord Telegram Telegram Medium ｜ Medium Linkedin This story was distributed as a release by Btcwire under HackerNoon’s Business Blogging Program. Learn more about the program here. This story was distributed as a release by Btcwire under HackerNoon’s Business Blogging Program. Learn more about the program here . here here

Join Morph’s Revolution With The Launch Of Holesky Testnet

Heavy is the head that wears the crown during a Wall Street bull run, and Nvidia’s status as the king of the ongoing generative AI boom means that the stock can be especially vulnerable to the prospect of weakening investor appetite. Nvidia (NASDAQ:NVDA) became Wall Street’s most exciting story in 2023. The chipmaker rallied some 239% throughout the year, smashing through the $1 trillion market capitalization glass ceiling before peaking at a cap in excess of $2tn. The optimism, fuelled by the ongoing generative AI market rally, continued to make waves in the first-quarter of 2024. NVDA rallied almost 90% in the opening three months of the year to continue its strong spell of dominance. But finally, at the beginning of April, the stock took its biggest tumble in four years. The wider implications of the Nvidia sell-off are likely to shake up the entire generative AI market. Counting the Cost of NVDA Sell-Offs The first three weeks of April 2024 saw NVDA shed more than 15% of its value amid widespread investor sell-offs. Although greater degrees of volatility can be expected for stocks caught up in the hype phase of an emerging market, Nvidia’s April downturn has been the company’s biggest dip since the initial outbreak of the Covid-19 pandemic in March 2020. For Nvidia, the pandemic era must seem like a lifetime ago. Its March 2020 sell-offs saw the stock tumble to $51.44. The stock’s peak closing price in March 2024 was $950.02. But after four years of meteoric growth, Nvidia’s recent market downturn is particularly concerning–particularly now the stock’s gained the status as a tech pioneer that’s been driving the S&P 500 higher on a consistent basis. Nvidia’s position at the pinnacle of the generative AI boom could mean that the stock would always be the first to absorb the impact of a change in investor sentiment, and the fears are that NVDA would be the canary in the mine should we suddenly discover that generative AI has been in a hype bubble that’s ready to burst for some time. Although Nvidia’s recent difficulties have coincided with the news that US inflation rates have continued to defy expectations, placing the prospect of interest rate cuts on hold for the foreseeable future, analysts suggest that fears over a cooling generative AI boom remain the key cause of investor concern in the wake of the underperformance. “The stock pullback has very little to do with rates,” explained Parag Thatte, strategist at Deutsche Bank, in a recent Financial Times interview. “It’s more to do with investors pricing in slower earnings growth.” There’s also a growing concern that generative AI has begun to transform from its hype phase towards the question of implementation. While Large Language Models (LLMs) like ChatGPT have been excellent tools in showcasing the sheer power and potential of generative AI, they’ve also been largely error-prone in a manner that could cause more hesitancy among enterprises seeking to embrace the technology. It’s for this reason that Gil Luria, analyst at DA Davidson, warned that a 20% slide in Nvidia stock could take place by the end of 2024. Luria suggests that the implementation phase of Nvidia’s products, which are currently being bought en masse by the likes of Microsoft and Amazon, could run into trouble when key buyers reach capacity and demand begins to fall. However, other analysts suggest that the end of the generative AI hype phase will be met by a more strategic implementation phase which could keep the industry growing. “Concerns about GenAI failing to meet expectations in 2024 should be seen in the context of the natural cycle of hype and maturity of new technologies,” said Maxim Manturov, head of investment research at Freedom Finance Europe. “While some industry leaders have expressed frustration with the speed of progress in artificial intelligence and GenAI in their organisations, others remain optimistic about its potential.” “Companies heavily invested in GenAI are under pressure to prove profitability, and industry reports indicate a shift to more strategic AI initiatives in the coming years,” Manturov added. Is the Generative AI an Exceptional Case? Here, it’s worth reminding ourselves that we’re talking about the generative AI boom. This is an industry that Bloomberg Intelligence last year suggested would grow at a CAGR of 42% into a $1.3 trillion industry by 2032. Fresh demand for generative AI products was predicted to add around $280 million in new software revenue. Could we be talking about an emerging technology that’s market impact is without precedent? Morgan Stanley analysts have underlined the indecisive outlook for Nvidia and the wider generative AI market in Q2 2024 by proposing a more bullish outlook for NVDA as well as the generative AI-focused Amazon (AMZN). As Nvidia reported Q4 2023 revenue increases of 265% to $22 billion, CEO Jensen Huang claimed that "accelerated computing and generative AI have hit the tipping point," before adding that "demand is surging worldwide across companies, industries and nations." The company’s innovations in recent weeks have included the text-to-3D tool, LATTE3D, which Nvidia described as a ‘virtual 3D printer’, as well as a collaboration with Hipocratic AI to develop a network of generative AI nurses that could cost $9 an hour. Nvidia’s quick 5% rebound following its record sell-offs should serve as a wider vote of confidence in the innovation that the company is capable of. Regardless of whether its success has made it the GenAI canary, NVDA is certainly an innovative stock that’s capable of sustaining its impressive growth. Bubble or Boom? Ultimately, Nvidia’s performance over the past 12 months means that the stock has become a live litmus test for investor sentiment in generative AI. Whether that’s a good thing or not depends wholly on the capabilities of the industry itself. Nvidia’s rapid growth has seen the stock rub shoulders with the likes of Microsoft, Apple, and Alphabet, and the company will be keen to follow the lead of other industry giants to continue sustaining its growth through innovation. As a semiconductor leader, the possibilities are nearly endless for Nvidia. As long as the capabilities of generative AI continue to astound clients and deliver on its promises, NVDA remains a stock that can continue to grow. If investors get a whiff of saturation or inefficiency, the Nvidia litmus test could face some further challenges ahead. Heavy is the head that wears the crown during a Wall Street bull run, and Nvidia’s status as the king of the ongoing generative AI boom means that the stock can be especially vulnerable to the prospect of weakening investor appetite. Nvidia (NASDAQ:NVDA) became Wall Street’s most exciting story in 2023. The chipmaker rallied some 239% throughout the year, smashing through the $1 trillion market capitalization glass ceiling before peaking at a cap in excess of $2tn. Nvidia The optimism, fuelled by the ongoing generative AI market rally, continued to make waves in the first-quarter of 2024. NVDA rallied almost 90% in the opening three months of the year to continue its strong spell of dominance. But finally, at the beginning of April, the stock took its biggest tumble in four years. The wider implications of the Nvidia sell-off are likely to shake up the entire generative AI market. Counting the Cost of NVDA Sell-Offs The first three weeks of April 2024 saw NVDA shed more than 15% of its value amid widespread investor sell-offs. Although greater degrees of volatility can be expected for stocks caught up in the hype phase of an emerging market, Nvidia’s April downturn has been the company’s biggest dip since the initial outbreak of the Covid-19 pandemic in March 2020. For Nvidia, the pandemic era must seem like a lifetime ago. Its March 2020 sell-offs saw the stock tumble to $51.44. The stock’s peak closing price in March 2024 was $950.02. But after four years of meteoric growth, Nvidia’s recent market downturn is particularly concerning–particularly now the stock’s gained the status as a tech pioneer that’s been driving the S&P 500 higher on a consistent basis. Nvidia’s position at the pinnacle of the generative AI boom could mean that the stock would always be the first to absorb the impact of a change in investor sentiment, and the fears are that NVDA would be the canary in the mine should we suddenly discover that generative AI has been in a hype bubble that’s ready to burst for some time. Although Nvidia’s recent difficulties have coincided with the news that US inflation rates have continued to defy expectations, placing the prospect of interest rate cuts on hold for the foreseeable future, analysts suggest that fears over a cooling generative AI boom remain the key cause of investor concern in the wake of the underperformance. prospect of interest rate cuts on hold prospect of interest rate cuts on hold “The stock pullback has very little to do with rates,” explained Parag Thatte , strategist at Deutsche Bank, in a recent Financial Times interview. “It’s more to do with investors pricing in slower earnings growth.” explained Parag Thatte explained Parag Thatte There’s also a growing concern that generative AI has begun to transform from its hype phase towards the question of implementation. While Large Language Models (LLMs) like ChatGPT have been excellent tools in showcasing the sheer power and potential of generative AI, they’ve also been largely error-prone in a manner that could cause more hesitancy among enterprises seeking to embrace the technology. largely error-prone largely error-prone It’s for this reason that Gil Luria, analyst at DA Davidson, warned that a 20% slide in Nvidia stock could take place by the end of 2024. Luria suggests that the implementation phase of Nvidia’s products, which are currently being bought en masse by the likes of Microsoft and Amazon, could run into trouble when key buyers reach capacity and demand begins to fall. 20% slide in Nvidia stock 20% slide in Nvidia stock However, other analysts suggest that the end of the generative AI hype phase will be met by a more strategic implementation phase which could keep the industry growing. “Concerns about GenAI failing to meet expectations in 2024 should be seen in the context of the natural cycle of hype and maturity of new technologies,” said Maxim Manturov, head of investment research at Freedom Finance Europe . “While some industry leaders have expressed frustration with the speed of progress in artificial intelligence and GenAI in their organisations, others remain optimistic about its potential.” Freedom Finance Europe Freedom Finance Europe “Companies heavily invested in GenAI are under pressure to prove profitability, and industry reports indicate a shift to more strategic AI initiatives in the coming years,” Manturov added. Is the Generative AI an Exceptional Case? Here, it’s worth reminding ourselves that we’re talking about the generative AI boom. This is an industry that Bloomberg Intelligence last year suggested would grow at a CAGR of 42% into a $1.3 trillion industry by 2032 . $1.3 trillion industry by 2032 $1.3 trillion industry by 2032 Fresh demand for generative AI products was predicted to add around $280 million in new software revenue. Could we be talking about an emerging technology that’s market impact is without precedent? Morgan Stanley analysts have underlined the indecisive outlook for Nvidia and the wider generative AI market in Q2 2024 by proposing a more bullish outlook for NVDA as well as the generative AI-focused Amazon (AMZN). more bullish outlook more bullish outlook As Nvidia reported Q4 2023 revenue increases of 265% to $22 billion, CEO Jensen Huang claimed that "accelerated computing and generative AI have hit the tipping point," before adding that "demand is surging worldwide across companies, industries and nations." claimed that claimed that The company’s innovations in recent weeks have included the text-to-3D tool , LATTE3D, which Nvidia described as a ‘virtual 3D printer’, as well as a collaboration with Hipocratic AI to develop a network of generative AI nurses that could cost $9 an hour. text-to-3D tool text-to-3D tool collaboration with Hipocratic AI collaboration with Hipocratic AI Nvidia’s quick 5% rebound following its record sell-offs should serve as a wider vote of confidence in the innovation that the company is capable of. Regardless of whether its success has made it the GenAI canary, NVDA is certainly an innovative stock that’s capable of sustaining its impressive growth. Bubble or Boom? Ultimately, Nvidia’s performance over the past 12 months means that the stock has become a live litmus test for investor sentiment in generative AI. Whether that’s a good thing or not depends wholly on the capabilities of the industry itself. Nvidia’s rapid growth has seen the stock rub shoulders with the likes of Microsoft, Apple, and Alphabet, and the company will be keen to follow the lead of other industry giants to continue sustaining its growth through innovation. As a semiconductor leader, the possibilities are nearly endless for Nvidia. As long as the capabilities of generative AI continue to astound clients and deliver on its promises, NVDA remains a stock that can continue to grow. If investors get a whiff of saturation or inefficiency, the Nvidia litmus test could face some further challenges ahead.

Stories, News & Mentions about TSET

Tset’s Stories on HackerNoon

Tset's News & Mentions