StockLyft

stocklyft

Meet the Winners of Startups in North and Central America

Lyft and Uber. Two unicorns valued at $15 billion and $120 billion, respectively. 2019 is the year where both of them could make their public debut with a forthcoming IPO. Through an initial public offering, the owners could sell a portion of the firm to public investors, essentially raising money that could help these two ride-sharing companies expand towards new markets, like autonomous cars and bike sharing. The process is more complex than it seems, though. Prior to the IPO, the companies need to negotiate a sale of their stock to an investment bank that acts as an underwriter for the offering. We’ve seen this before, but given the fact that currently the volume of IPOs has soared to its highest level since the dotcom bubble in 2000, is it still the best option to make an investment in these giants (essentially a drop in the ocean), or should you look for other opportunities? For example, on-demand private jet app (Uber for private jets) already announced its . Much like the giants of the Internet, the company is profitable, has a real business model, paying customers, growing sales, and the potential to become a unicorn in its space is going public, choosing cryptocurrency instead of stock. Do you want to find out why and if this could be a better deal than any upcoming IPO this year? I’m covering all of these in the following article. Keep reading! TapJets security token offering (STO) https://wi-images.condecdn.net/image/8nAmmzp4XPQ/crop/1440/0.5235602094240838/f/dumbrella.jpg Still thinking about investing in Lyft and Uber? Even if both companies showed their interest to go public, they still need to from the US Securities and Exchange Commission (SEC) on their filings for IPOs. receive feedback Both companies are innovative and disrupt the space. There’s no doubt about that. But on the profit growth side, which defines if investors would make a profit too, there is a huge amount of skepticism. Uber had its recently: allegations of sexual harassment within the company, an exodus of C-level talent from the company, legal battles with Alphabet, Google’s parent company, and after years of activity it’s still showing a complete and utter lack of profits! Despite all of these facts, Uber received valuation proposals from , which often happens before a company officially hires a bank to underwrite its offering. up and downs Goldman Sachs and Morgan Stanley On the other side, we can’t know for sure, but Alphabet (which was one of Uber’s first big investors) already made into Uber’s rival company, Lyft. It can be interpreted as “moving on” after a wrong financial decision in the first known ride-sharing app. Investors may now be tempted to leave Uber stock by the curb and buy into Lyft instead. That’s why 2019 could be seen as a race for these two private companies to . a big investment go public https://www.bloomberg.com/news/articles/2018-06-15/tech-ipos-surge-for-another-day-but-why-is-anyone-s-guess Before you’re thinking about picking sides in this battle, you should know that you need to be an accredited investor and be able to make a minimum deposit of just to get a seat at the table. Not really for everyone, right? $100,000 to $500,000 The blockchain and secure token offerings are disrupting traditional stock sale transactions If history has taught us anything, it’s that those who adapt will survive, and those who fight tooth and nail for the status quo will flounder when the world inevitably changes. , which is as similar as it can be to Lyft and Uber, is not going for an IPO. The company elected to take an STO route, which involves the sale of tokens that represent common stock and records on the blockchain, as opposed to the traditional stock shares managed by banks or exchanges. TapJets Just like Uber, Lyft, Airbnb,and eBay, TapJets is a built around network effects and transaction fees. The proof of their successful business model is a two-year-old product that attracted thousands of customers and millions in sales. And to stay competitive and innovative in a complex industry they utilize the blockchain as part of their commitment to transparency and safety for each booked flight. two-sided marketplace The traditional way of building a two-sided marketplace business involves using to create a marketplace. Funds are raised from founders, accredited investors, and institutions with one goal: become profitable as soon as possible. With the huge amount of money, Uber and Lyft employees with equity and early marketplace participants with zero transactions fees with the hope that, at some point, they will be able to increase the fees as their marketplace increases in scale and monopoly power. The growth value was expected from the appreciation of the equity because of the future cash flows from these transaction fees. Which after years of activity! equity financing rewarded hasn’t happened http://www.businessofapps.com/data/uber-statistics/ The process is completely different using crypto tokens. An allows the company to accept money from anyone around the world. In the case of TapJets, investments are available to , while non-US investors are free to participate in strict compliance with . Unlike the ICO (initial coin offering) model of the past, all these individual would become real shareholders of the company after making an investment, with either fiat or cryptocurrency, which will be marked as a blockchain recorded security. The growth value in this situation is expected from the increasing value of the token, which is tied to matching as many willing buyers and sellers as possible. Transaction fees are out of the equation. In the crypto token version of a two-sided business, the marketplace value is given by all its participants, not only from the ones willing to pay. “Power to the people!” is taken quite literally in this case. STO financing model accredited investors in the US Regulation S Well, the short answer is: it couldn’t happen even if they wanted to. Pretending that a token issuance (an STO) could happen. This action would dilute the current stock price or, even worse, force them to split the company into multiple entities, thereby damaging their reputation with the current shareholders. It’s hard to believe this would ever happen. Could Lyft or Uber have an STO, though? STO: A new investment model for the future After more than three years of running their business and facing continued growth in sales and clients, is ready to offer investors a chance to invest in their success. While venture-funded startups are struggling to reach their revenue, product maturity, and financial history after their initial funding, TapJets is opening its gates at a more advanced stage of their business, which implies less risk for its investors. Would you put your money into an early-stage startup aiming towards an idea, or into a company with a proven team, supporters, and a working product? TapJets “Our ability to book a private jet faster than you can get an Uber ride is simply revolutionary. We leverage Artificial Intelligence, data analytics, and predictive modeling to connect our clients to jets that are ready to take off,” Eugene Kesselman, CEO of TapJets. from https://www.tapjets.com/ An idea is not enough anymore. Only the tech startups that have the right financials will be ripe for tokenization. ICOs might have been in non-dilutive capital formation, but most ICOs have not been successful in producing . STOs can enable innovative companies to expand to their true potential. Uber and Lyft’s early investing stages have been gone for a long time, and joining their IPO doesn’t look profitable for any type of investment. When looking for other opportunities in the future, STOs could be the right choice if you believe in a digital future! a revolution any general business benefits

If Lyft or Uber had an STO, how much would you invest?

For my first ever wrote article, I've decided to write about web scraping and how I built a Stock Market Watcher using Ruby and Nokogiri Gem. First of all some requirements to follow this guide: Ruby HTML/CSS basics The purpose of this guide is to show what you can do using Ruby, probably out there you'll find better/professional ways to do this. The repository containing the complete code used on this guide will be linked at the end of the article. Let's begin First of all, set up your environment, create a ruby file that will contain our scrapper code. In this case, I'll create a file called stock_watcher.rb and I'll add the following code to it. #stock_watcher.rb require 'nokogiri' require 'open-uri' This code requires a Ruby Gem called (Help us to handle extracted data from the website) and the open-uri module to extract data from the web. Nokogiri After this, we need to define from where we're going to get the data for our scrapper, here you can use any website you wish, for this guide I'm going to use data. TradingView With the source defined now we need to get the data from the page, Nokogiri got some useful parsing methods to help us, we're going to use the parser since we're scraping an HTML page. Nokogiri::HTML Add the following code to stock_watcher.rb page = Nokogiri::HTML(URI.open( )) #stock_watcher.rb 'https://www.tradingview.com/markets/stocks-usa/market-movers-large-cap' This simple get the data from the web using the URI module and parse it using Nokogiri, it returns a . Nokogiri::HTML::Document With our page object, we have in our hands a bunch of useful methods. Now we have to use our HTML/CSS acknowledgment to define from where on the page we want to get the data. Chrome dev tools is a good friend here. The page in question is , this page shows us the US STOCK MARKET companies ordered by large capitalization. This page stores data on the main table as you can see, what we have to find is a way to identify this table. https://www.tradingview.com/markets/stocks-usa/market-movers-large-cap/ Nokogiri offers us a method called "css" that lets us search for specific CSS rules on our , we can search for specific CSS classes, ids, etc... Nokogiri::HTML::Document Let's try to find out what's the class or ID of the table using the Chrome inspect tool, just right click on any table element then inspect, you'll find a window similar to that one: Scroll a bit till you find the <table> tag like this: As you can see our table uses the "tv-data-table" class, that one is going to be our target class. Now we got our table class, add the following code to : stock_watcher.rb table = page&.css( ); #stock_watcher.rb '.tv-data-table' This code get our page object and find an HTML element with "tv-data-table" class assigned to it and returns a . Nokogiri::XML::NodeSet The only thing we need from the table is the table data, the table data (td) is stored inside the table rows (tr). offers more useful methods that allow us to search for specific keys inside it. Nokogiri::XML::NodeSet Add the following code to : stock_watcher.rb rows = table.search( ); #stock_watcher.rb 'tr' This returns another with a subset of keys and values from the table that contains 'tr'. Nokogiri::XML:NodeSet We're getting close to our goal. Now add the following code to : stock_wacher.rb rows.each stock_content = row.search( ).map { td.text.strip }
  stock_content[ ]&.gsub!( , ) do |row| 'td' |td| 0 "\n\t\t\t\t\t\t\t\t\t" " " end Now we iterate over our XML subset, in this case, it's our rows containing the data from stocks. Then we search in every row for the table data (td) using the same method search, it returns an array with all the data of the iterated row. We need to strip our text because Nokogiri returns a lot of useless pieces of text inside our strings. Now you can play a bit with that code, try to print the stock content you got using "puts stock_content" before the end keyword of the last code and see what you got, it should return something similar to this: MSFT Microsoft Corp. % Buy M B Technology Services "[" ", " 182.51 ", " -2.27 ", " -4.23 ", " ", " 31.952 ", " 1384.054 ", " 31.09 ", " 6.06 ", " 144000.00 ", " "]" With this data in hand who define what should be done next is you, there are thousands of possibilities of what could be done with this, I'll give a few examples: Store data on a file for later checking, store data on a database to handle it later even showing the data on another website (Check for permissions first), create triggers if a stock value is on a price that you want. As I said, there are a lot of possibilities. Now to finish this guide I've created a class to handle the data we got from our last piece of code. First, create another file on the same folder called stock.rb and add the following code: , , , , , , @name = stock_data[ ]
    @last = stock_data[ ]
    @change_percentage = stock_data[ ]
    @change_value = stock_data[ ]
    @rating = stock_data[ ]
    @vol = stock_data[ ]
    @market_cap = stock_data[ ] #stock.rb class Stock attr_reader :name :last :change_percentage :change_value :rating :vol :market_cap def initialize (stock_data) 0 1 2 3 4 5 6 end end I'm not going to explain how classes work on Ruby since that is not the purpose of this guide. But basically, that class receive the data we got on the "stack_content" variable and store it elegantly. Now replace your entire code on file to look like this: stock_watcher.rb require_relative page = Nokogiri::HTML(URI.open( ))
table = page&.css( );
rows = table.search( );
stock_arr = []
rows.each stock_content = row.search( ).map { td.text.strip }
  stock_content[ ]&.gsub!( , )
  stock_arr << Stock.new(stock_content) stock_content.length.positive? #stock_watcher.rb require 'nokogiri' require 'open-uri' 'stock' 'https://www.tradingview.com/markets/stocks-usa/market-movers-large-cap' '.tv-data-table' 'tr' do |row| 'td' |td| 0 "\n\t\t\t\t\t\t\t\t\t" " " if end It requires our new class file, creates a new array called stock_arr, and store every new stock object on it. If you print the first object on stock_arr you'll get something like this: MSFT Microsoft Corp. - % - Buy M B "#<Stock:0x00007fffd443e2f8 @name=" ", @last=" 182.51 ", @change_percentage=" 2.27 ", @change_value=" 4.23 ", @rating=" ", @vol=" 31.977 ", @market_cap=" 1384.054 ">" As you can see, it's a better way to store our stocks, and you can access its properties using dot notation, like stock.name, stock.last, stock.change_value, etc... Thank you for reading this guide, I hope it helps you in some way. Feel free to contact me on any social media listed on HackerNoon. Useful links: Complete code repository: https://github.com/kazumaki/stock-market-watcher TradingView website: https://www.tradingview.com/ Nokogiri documentation: https://nokogiri.org/rdoc/index.html

How to Create a Stock Market Price Watcher Using Ruby

Object-relational mappers (ORMs) are often used in Python programming when one needs to develop an application that works with databases. Examples of Python ORMs are SQLAlchemy, Peewee, Pony-ORM and Django. When choosing an ORM,  performance plays a crucial role. But how are these toolsets compared? ORM performance benchmarks offer a measure of clarity but leave considerable room for improvement. I examine and extend the qualitative ORM benchmark to develop a stronger metric. The qualitative Python ORM benchmark, Tortoise ORM, ( ) analyzes the speed of six ORMs for eleven types of SQL queries. In general, the Tortoise benchmark makes it possible to evaluate the speed of query execution for the various  ORMs. However there is a flaw with this approach to testing: most ORMs are selected for use in web applications. In such contexts multiple users send all manner of queries to a database often at the same time. Because no benchmark measurement tools evaluated could rate performance of Python ORMs in a scenario like this, I decided to write my own comparing PonyORM and SQLAlchemy. As a basis, I took the TPC-C benchmark. link to the repository Since 1988, has been developing tests in the field of data processing. They have long become an industry standard and are used by almost all vendors of equipment on various samples of hardware and software. The main feature of these tests is that they are focused on testing under enormous load in conditions as close as possible to real ones. TPC simulates a warehouse network. It includes a combination of five simultaneously executed transactions of various types and complexity.The purpose of the test is to evaluate the speed of transaction processing when several virtual users simultaneously access the database. TPC-C I decided to test two Python ORMs (SQLALchemy and PonyORM) using the TPC-C testing method adapted for this task. The purpose of the test is to evaluate the speed of transaction processing when several virtual users access the database at the same time. Test description Step one is to create and populate the database of a warehouse network. The database schema looks like : this The database consists of eight relations: Warehouse District Order OrderLine Stock Item Customer History Databases for Pony and SQLAlchemy are identical.  Only primary and foreign keys are indexed. Pony made those indexes automatically. In SQLAlchemy I made it manually. During the test, different types of transactions are sent to the database from several virtual users. Each transaction consists of several requests. In total, there are five types of transactions that are submitted for processing with different probability of occurrence: Transactions: new_order - 45% payment - 43% order_status - 4% delivery - 4% stock_level - 4% The probability of occurrence of transactions is the same as in the original TPC-C test. However, bearing in mind that toriginal TPC-C test is conducted on servers with 64+ GB of RAM (requiring a large number of processors and huge disk space), due to technical limitations and and the fact that I wanted to test the performance of ORMs and not the resistance of hardware to enormous load, this test is somewhat simplified. The main differences from the TPC-C test are as follows: Main differences: The test runs with fewer virtual users than in the original test My test has less table entries. For example: the number of entries in the relation “Stock” in the original test is calculated using the formula 100,000 * W, where W is the number of warehouses. In this test it’s 100 * W. In the TPC-C, some of the transactions have several options for querying data from the database. For example, in a Payment transaction, with one probability, the client will be requested from the database by ID, with another by last name and first name. At the moment, my test only makes calls by ID. My test database is one table less than the TPC-C. In the TPC-C test, when an order is created, it is added to both the Order table and the NewOrder table. After delivery of the order, it is then deleted from the NewOrder table. This speeds up work  when a huge number of transactions per minute is applied; but since I have fewer users accessing the database, this is unnecessary. Instead, in the Order table, I added the bool attribute “is_o_delivered”, which will be False, until the order is delivered. Next, I will briefly describe what each transaction does. Transactions New Order Passing two arguments to the transaction: warehouse ID and customer ID Selecting the warehouse and the customer from the database using the passed IDs Selecting one randomly chosen district of the warehouse from  database Generating a random number that indicates the number of order lines. Creating an Order object Creating OrderLine objects in loop. In each iteration of the loop selecting one random item from the Item table Changing Stock for each item in the order Payment Passing two arguments to the transaction: warehouse ID and customer ID Selecting the warehouse and the customer from the database by the passed IDs Selecting one randomly chosen district of the warehouse from  database Generating a random number that indicates the payment amount Increasing balances of Warehouse and District by the payment amount Decreasing balance of  customer by the payment amount Incrementing customer payment counter Increasing sum of customers payment amounts by the payment amount Creating History object Order Status Passing customer ID as an argument of the transaction Selecting customer by ID and last order of this customer Taking order status and order lines from order. Delivery Passing warehouse ID as an argument of the transaction Selecting warehouse and all of its districts from the database For every district selecting the oldest not delivered order. For every order changing delivery status to True For every customer of orders incrementing order count Stock Level Passing warehouse ID as an argument of the transaction Selecting warehouse from the database by ID Selecting last 20 orders of this warehouse For every item in orders taking stock level of item Test results Two ORMs are participating in the test: SQLAlchemy (blue line on graph) PonyORM (orange line on graph) Below are the results of running the test for 10 minutes with 2 parallel processes accessing the database. Processes are launched using the “multiprocessing” module. X axis - time in minutes Y axis - number of completed transactions As DBMS I use PostgreSQL All transactions First, I ran the test with all five transactions, as expected in the TPC-C test. As a result of this test, Pony was about twice as fast. Average speed: Pony -  2543 transactions/minute SQLAlchemy - 1353.4 transactions/minute After that, I decided to evaluate the performance of ORMs on each of the five transactions separately. Below are the results for each individual transaction. New Order Average speed: Pony - 3349.2 transactions/minute SQLAlchemy - 1415.3 transactions/minute Payment Average speed: Pony - 7175.3 transactions/minute SQLAlchemy -  4110.6 transactions/minute Order Status Average speed: Pony - 16645.6 transactions/minute SQLAlchemy - 4820.8 transactions/minute Delivery Average speed: SQLAlchemy - 716.9 transactions/minute Pony - 323.5 transactions/minute Stock Level Average speed: Pony - 677.3 transactions/minute SQLAlchemy - 167.9 transactions/minute Analysis of test results After receiving the results, I analyzed why they are like this and came to the following conclusions: In 4 out of 5 transactions, PonyORM turned out to be faster, because, when generating SQL code, PonyORM remembers the result of translating Python expressions into SQL. Because of this Pony does not translate the expression again when the query is repeated, while SQLAlchemy is forced to generate SQL code every time when needed to execute a query. Example of this kind of query in Pony: stocks = select(stock stock Stock stock.warehouse == whouse stock.item items).order_by(Stock.id).for_update() for in if and in Generated SQL: . , . , . , . , . , . , . , . . = %(p1)s . (%(p2)s, %(p3)s) . { : , : , : } SELECT "stock" "id" "stock" "warehouse" "stock" "item" "stock" "quantity" "stock" "ytd" "stock" "order_cnt" "stock" "remote_cnt" "stock" "data" FROM "stock" "stock" WHERE "stock" "warehouse" AND "stock" "item" IN ORDER BY "stock" "id" FOR UPDATE 'p1' 7 'p2' 7 'p3' 37 SQLAlchemy: stocks = session.query(Stock).filter(
    Stock.warehouse == whouse, Stock.item.in_(
    items)).order_by(text( )).with_for_update() "id" Generated SQL: stock.id stock_id, stock.warehouse_id stock_warehouse_id,
    stock.item_id stock_item_id, stock.quantity stock_quantity,
    stock.ytd stock_ytd, stock.order_cnt stock_order_cnt,
    stock.remote_cnt stock_remote_cnt, stock.data stock_data stock stock.warehouse_id = %(warehouse_id_1)s stock.item_id (%(item_id_1)s, %(item_id_2)s) { : , : , : } SELECT AS AS AS AS AS AS AS AS FROM WHERE AND IN ORDER BY id FOR UPDATE 'warehouse_id_1' 7 'item_id_1' 53 'item_id_2' 54 But, Apparently, SQLAlchemy performs delivery type transactions faster because it can combine several UPDATE operations applied to different objects into a single command. Example: INFO:sqlalchemy.engine.base.Engine: order_line delivery_d=%
    (delivery_d)s order_line.id = %(order_line_id)s
INFO:sqlalchemy.engine.base.Engine:(   
    { : datetime.datetime( , , , , , , ), : },
    { : datetime.datetime( , , , , , , ), : },
    { : datetime.datetime( , , , , , , )) UPDATE SET WHERE 'delivery_d' 2020 4 6 14 33 6 922281 'order_line_id' 316 'delivery_d' 2020 4 6 14 33 6 922272 'order_line_id' 317 'delivery_d' 2020 4 6 14 33 6 922261 Pony in situations like this sends separate query for each update. Conclusion Based on the results of this test, I can say that Pony selects from the database much faster. On the other hand SQLAlchemy in some cases can produce queries of Update type with significantly higher speed. In the future, I plan to test other ORMs (Peewee, Django) this way. Links Code of the test: repository SQLAlchemy: , documentation community Pony: , documentation community

Stories, News & Mentions about STOCKLYFT

Stocklyft’s Stories on HackerNoon