Robert Kawada, 43, is facing charges of poisoning, assault and battery with a dangerous weapon on a pregnant person, and assault and battery on a household or family member, officials said.

Brookline man charged with tricking woman into ending pregnancy to be arraigned in Waltham District Court

WALTHAM, MASS. (WHDH) - A 43-year-old Brookline man accused of tricking a woman into ending her pregnancy by secretly giving her medication was arraigned TuesdayRead More

Prosecutors: Brookline man accused of poisoning pregnant woman gave her labor-inducing cookies, fake iron pills - Boston News, Weather, Sports | WHDH 7News

Brookline Man Accused Of Secretly Giving Girlfriend Abortion Drug - Brookline, MA - Officials say the man secretly gave a woman he was dating pregnancy-ending medication under the guise that he was giving her vitamins.

Brookline Man Accused Of Secretly Giving Girlfriend Abortion Drug | Brookline, MA Patch

Robert Kawada was scheduled to be arraigned Tuesday.

Brookline man charged with tricking woman into taking medication to end pregnancy

A Brookline, Massachusetts, man is facing criminal charges after authorities say he tricked a woman he was dating into taking a medication that ended her pregnancy. Robert Kawada, 43, was charged with assault and battery with a dangerous weapon on a pregnant person and assault and battery on ...

Brookline man accused of tricking woman into ending her pregnancy – NBC Boston

Bookline

bookline

Loneliness and the Biography of a Living Person

Have you ever dreamed to wake up one morning and realize you felt different, more powerful. As if you had this super power inside of you that it waiting to be used. You'd meet someone very old and wise. He would tell you that you've actually had this super power for a very long time. But you need to go through a very difficult training phase to master it. This article was first published on my blog . Good news: as a developer, you do have this super power. And although you will need to practice, I promise you it sure won't be that difficult. This super power is called . Deep Work It was made famous by the author and computer science researcher in his 2016 . Here is one definition of Deep Work you can find : Cal Newport book of the same name in the book's abstract “Deep work is the ability to focus without distraction on a cognitively demanding task. It’s a skill that allows you to quickly master complicated information and produce better results in less time. Deep work will make you better at what you do and provide the sense of true fulfillment that comes from craftsmanship. In short, deep work is like a super power in our increasingly competitive twenty-first century economy.” Why Do I Need Deep Work? Deep work will improve your life as a developer in several ways. The first obvious one is that you'll feel (and be) more productive. You'll deliver your tasks quicker, with a better quality. And you'll feel more involved in your projects. Without falling into the myth of the “10x-developer”, you will impress your coworkers with the exceptional rate of your work. You'll also improve your level as a developer. Because you'll work faster, you'll also progress a lot faster that before. Suppose you're a front-end developer and use to work on UI stories (updating a form, creating a new screen). It won't be long before you'll have so much experience that you want to find ways to optimize everything. Testing new libraries to make things easier, improve performance, and make a lot of refactoring. And all this will be a huge plus for your career. Last advantage of deep work that I can see, you'll separate better your personal life from your professional one. You'll be better at stopping thinking about work when you leave the office. And you'll even be better at enjoying your leisure time on evenings and weekends. “The key to developing a deep work habit is to move beyond good intentions and add routines and rituals to your working life.” The thing is, working deeply is not difficult in theory. You just have to... well, work. The hardest part is actually what you do when you don't work deeply, to help you when you do. Let's see what routine you can put in place to be able to apply deep work in a classic day of work. I'll imagine you're a developer in a company because it's my personal situation. Of course most principles will apply if you're not. 🕖 Arrive at The Office, the Earlier the Better Everything starts as soon as you arrive at the office. If like most developers you work in an open plan office, you can guess why it is not an optimal condition for deep work. It's often noisy and distraction is all around (conversations, phone calls...). Focus loss can also come from instant messaging, emails, more or less useful meetings. But above all, a lot of context switching. A colleague interrupts you for an innocent easy question. It takes only a couple of minutes of your time. But the damage is done, you lost your precious concentration. One of the solutions I applied to counter this is pretty drastic: I started to arrive at 7 a.m. every morning. As I explain in a previous post, by starting working this early, I had a lot of time to work deeply, before any of my colleagues arrives. For more than two hours, it's only me and my work: no meetings, no noise, no context-switching. Imagine how it feels to have delivered several tasks before your colleagues even have their first cup of coffee. Of course it may not be that easy to arrive this early. If your employer doesn't let you adjust your working hours as you want, or if you have kids, or if you're definitely not a morning person, don't be afraid. There are still other tricks to be able to work deeply. One of the first thing I do when I arrive is trying to plan my day. First by having a look at my agenda to see if I have important meetings (or less important ones, that I can miss). But it's more important to define what your day will look like. Not exactly which specific tasks you'll work on (we'll talk about that further). But try to plan when in the day you have deep work sessions, when you have a break with colleagues, or when you do shallow work (i.e. non-deep work). Try not to be too much ambitious at first. Two hours in the morning and two in the afternoon may be enough to begin. You'll already produce a lot more than before. Last step before starting your first deep work session of the day: have your morning ritual. Cal Newport suggests that before starting a deep work session you do a few actions you set for yourself. Like a routine to tell your brain “prepare for a very intense work session”. For me this ritual consists first in preparing a large cup of coffee. Then turning off all notifications (phone, IM, e-mails). Making sure that only work-related windows and browser tabs are open. And finally choosing an album or a playlist to listen. By the way, my noise-cancelling earphones are my best friends. The day can begin. Four Depth Philosophies In his book Cal Newport describes four ways to apply deep work principles. They depend on how much and for how long you can focus on a specific task. The consists in dedicate your life to deep work; Monastic Philosophy With the , you dedicate two or more days of your week to deep work; Bimodal Philosophy The encourages to dedicate predefined hours of your day to deep work; Rhythmic Philosophy And, finally, the consists in applying deep work every time you can. Even for very short periods. Imagine a journalist that leaves a party for 30 minutes to work deeply on an article. Journalistic Philosophy As you can imagine, the Rhythmic Philosophy seems to be the most adapted to us developers. But to me the Journalistic one is very interesting. I would love to be able to find times in a day for deep work, on personal or professional projects. The problem is that it can be very easy to think we're working deeply several times in a day, whereas we're actually not working deeply at all. Just switching context all day long. Before even considering the journalistic philosophy, applying a rhythmic one may be necessary. If you have a different experience about that, I'd be very glad to here from you. 🕤 Time For Some Shallow Work If you came to the office early, it must have been quiet until now, but here comes a time when everyone else arrives. The office is now very noisy, everyone talking about the series they watched last night. Good time to have a break, and a cup of coffee with colleagues. Also a good opportunity to do this shallow work you still need to do. Like answering some emails (or simply read some), planning your next team's lunch, etc. For me, this time usually includes the daily scrum at 10 a.m. After it, I also check my Twitter and RSS feeds. It may be a good time for technology watch (and you really need it in development). Be careful though to define first how much time you want to dedicate to this (while planning your day for instance). Maybe not more that 20 or 30 minutes. It's very easy to start and never finish going from Twitter to Reddit to nowhere all day long. Even if it looks like just checking development stuff. After that, starts another session of deep work until it's lunch time. Or maybe you need some help about a specific problem? 🕚 I Need Help From a Colleague Let's say you need to ask a coworker some help about a complex problem. (I'm not talking about a simple question such as asking for access codes.) First, suppose she might be in a deep work session herself, so ask her (by IM or email) when would be a good time. Don't expect an answer in the minute, remember you wouldn't like to be disturbed during a deep work session. Open plan offices defenders will argue that they encourage the kind of communication you need to solve these problems. Everyone is ready and available to answer any question. More generally, open offices would be better for creative ideas to emerge. Cal Newport refers to this idea as the theory of serendipitous creativity. Of course in a deep work philosophy this doesn't work. If you're always available, it could mean you never have full focus on a task. So should you say goodbye to communication and creativity? Of course not. A help session between two developers can be deep work too. Cal Newport refers to this as the white board effect. Define what problem you want to solve and what elements (answers) you'll need to continue by yourself. Also make sure nobody will distract you (find a meeting room for instance). Obviously the white board is not required, but you understand the idea. “Don’t Take Breaks from Distraction. Instead Take Breaks from Focus.” One common practice you can hear about is to define some time you won't use your cellphone or visit social media. For example, you decide that for one hour, or for the day, or for the weekend, you won't go on the Internet. This seems like a good idea at first sight, but it is actually taking a break from distraction. Instead, try to take breaks from deep work. Define moments you will allow yourself to go on the Internet for a given amount of time. Let deep work be your normal state, and distraction the exceptional one. 🕛 Lunch Break I wouldn't dare to tell you what to eat or how to enjoy your lunch. But there is something interesting you can do after. This will improve your deep work practice a lot. I'm talking about taking a walk (or a run, or bike session) and meditate productively. The idea is to find a work problem and try to solve it for instance. Or think about how to plan an upcoming meeting. Or prepare a presentation. It's not quite easy to keep focus while walking or running, especially if you can't take notes. But it's an excellent way to improve your memory and ability to concentrate. Interesting fact about memory that Cal Newport raises. Some people are able to remember a very complex things (a deck of cards, some number decimals...). Studies evaluated their memory, and their conclusion are surprising. Their ability to memorize things is not significantly better than anyone else's. But their ability to concentrate is. In other words, the remembering part relies on tricks more than memory. But these tricks need an ability to focus that must be trained. Have a look at . this method to memorize a deck of cards 🕒 After The Scrum Planning Let’s imagine that afternoon started with a sprint planning. So you now know what you’ll have to do for the next couple of weeks. Choose one of your tasks, and take the time that you and your team estimated it would take. Now estimate for yourself how much time you could use to do this task if you were perfectly productive. This could divide by two or three the original estimate, but commit to yourself (or better, to your team) about it. For example if a task was estimated to four days and it’s Monday, commit to finish it before Wednesday’s daily scrum. This can be rough, but having this goal will imply you’ll know exactly what to work on for the next days’ deep work sessions. According to Cal Newport research, this method is inspired by the one that Theodore Roosevelt himself used when he was a student. You’ll be surprised by how it actually works most of the time. Of course there will still be times when you’ll need some input by someone else, or another task to be delivered before you can finish yours. Still, most of the time it does work. In my team it even became some kind of a recurring joke: “estimated to five days of work, so it’ll be done by tomorrow, right?” 🕓 End of The Day, Go Home Your day of work ends, you go home, stop thinking about deep work and do everything exactly like before. Right? Well actually, there are still a few tricks to know, that will help you for the next days deep work sessions. Don't be afraid, I won't tell you to work deeply on the evening, unless you want to of course. First, remember when I talked about having a ritual to start the day of work? Well having one to end it can be very useful too. Cal Newport calls it the . Be sure you answered important emails, update your tasks status if you need to, clean up your desk... (Cleaning up my coffee cup is an important part of this ritual for me.) Shutdown Ritual In other terms, make sure that on the next day you'll be able to start working deeply as soon as you arrive. This is also important to prevent thinking about work on the evening. Because here is the second important point: once you leave the office, stop thinking about work. This may seam obvious. Yet I know a lot of people who still receive (and read) work email or IM notifications after they left. I can understand why. It's kind of practical to feel updated about what happens, even if it doesn't lead to any action from you. But this makes your brain not fully dedicated to the non-work activity you could have on the evening or week-ends. Even if you just read notifications. You could not rest as much as you want to, and as a result not be fully able to focus on the next day. So if possible, turn off all work-related notifications on your phone, and obviously don't work once you left the office. Conclusion: What About Personal Time? Far be it from me to tell you what you should do at home in the evenings and weekends. If you want to be fully proficient at deep work though, it's important to understand that it goes way further that what you do at work. We live in a world of constant distraction. Your cellphone vibrates several times a day, to show you a picture on Instagram, or the latest retweet of some people you follow on Twitter. But more disturbing when you think about it: we ourselves are constantly looking for distraction. Waiting in a line? We have a look at our smartphone and open Facebook, Instagram or Twitter. Sometimes we even know that there won't be anything new to see because we just had a look a couple of minutes ago. But it has became a reflex. The thing is, this addiction to distraction is not here only when we do “nothing”. It is when we work, when we try to focus, or when we're having a discussion with someone. We try to ignore it and stay focused. But at the first moment of weakness it's so easy to switch windows to the browser and open Twitter or Reddit. Or without even noticing, we check our smartphone for new notifications. Without taking care of the person we're talking with. If there was one point to keep from Cal Newport's book, I would choose this one: focus is an ability that should be trained. Imagine it as a muscle: if you don't train it regularly, it becomes weaker. And it's worse if you give it too much junk food (addictive and easy distraction). But, if you care about it and make sure to develop it on a daily basis, you'll be impressed by how quickly you can achieve things. Accomplish tasks, learn things, or just enjoying more your work or personal projects. Liked this article? Check out my other articles on my blog! Photos by Émile Perron , Artem Sapegin , David Mao , Tim Gouw , Corey Agopian , Avi Richards .

You Can Become a Better Developer by Mastering the Super Power of Deep Work Habit

Bittrex is among the largest and well-known crypto exchanges with over $160 Million of daily trading volume. Founded by Bill Shihara, who previously worked as a security engineer at Amazon and Blackberry, Bittrex exchange places a special emphasis on reliability and preventing security breaches. Bittrex is based in the USA, which is rare among the crypto exchanges. To date, Bittrex holds almost 300 cryptocurrencies, features fast deposits and withdrawals with a solid customer support. How to register to Bittrex (registration, verification and deposit funds) Registering on Bittrex is a relatively simple process. First you need to sign up by providing an email and a secure password. Next you will need to verify your email address. Once signed up, we will recommend you to secure your new account with 2 factor authentication (2FA) using Google authenticator app. Bittrex does require its users to verify their identity in order to make withdrawals. However, to avoid complications, they strongly recommend not to deposit any funds until the verification process is fully done. To verify your identity, click on the ‘settings’ tab on the top menu. Keep in mind, Bittrex will also frequently ask you to reconfirm your email if you’re signing in from a new IP address (on top the usual login and 2FA). Next, select “My Profile” to start the registration process. Once all fields are completed, click on the ‘Identity verification’ tab and click ‘start verification’. The process will require you to verify your identity using officially issued government IDs and/or passport. After all information is submitted, it should only take a few minutes for the system to process your information, ID, and photo. Once verified, you will receive a confirmation email and a notification on the identity verification page. Now you are ready to make deposits, congrats. To deposit coins, go to ‘Wallets’ tab from the top right menu. Here you can see your account balance, as well as the variety of tokens listed on. If you click on the green circle-arrow icon next to each coin, a pop up will come up asking you to generate a new wallet address. Click ‘new address’. Once the address is created, copy it and send the desired amount from your digital wallet in order to deposit to Bittrex. Double check that you deposit the correct coin to its corresponding wallet. Otherwise, it could result in a complete loss of your coins. After your transaction is confirmed with the number of confirmations Bittrex requires, your account will be credited and you are ready to begin trading. How to trade on Bittrex exchange On the home screen (or ‘markets’) page, you can search for your desired trading pair. The homepage displays featured trading pairs with their stats. Once you click on a specific trading pair, you will be directed to the market page. The top section of the page shows the chart, which can be adjusted by time frame, chart style (bar, colored bar, line, etc), indicators (ADX/DMS, Alligator, Awesome Oscillator, etc) and Select Tool (crosshairs, segment, continues, etc). Prices adjust in real time and deposits/withdrawals can be made directly on the pair’s page. Once you scroll a bit further down, you will see the order book. Here you can view all buy and sell orders (or ‘bid and ask’). Sum represents the total amount in the base asset accumulated to the specific order book line. In the middle box, select the desired price and number of units you prefer to place for the newly created order. Under ‘order type’ you can select ‘limit (Default)’ or ‘conditional’. A limit order is an order to buy or sell at a specified price (or cheaper if available). A ‘buy’ limit order is executed at the specified limit price or lower, while a sell limit order is executed at the specified limit price or higher. Limit orders help you get the best deal for your buy or sell (unlike ). decentralized exchanges You can also set a stop-loss command on Bittrex. Stop-loss is when you set a price you wish to sell a coin in order to limit your losses. It’s a great way to minimize risk if you buy a coin anticipating it will go up in price, but instead it goes down and you lose money. Stop-loses can be set using the Conditional orders feature. Conditional orders are more advanced trade orders that are automatically submitted or canceled if specified criteria are met. When clicking on ‘Conditional orders’ users can set the conditions to ‘greater than or equal to’ or ‘less than or equal to’ a target price. They can also set ‘Time in Force’, which provides 2 options; ‘Good-Til-Cancelled Order’, or ‘Immediate-Or-Cancel Order’. A Good-Til-Cancelled (GTC) order is an order to buy or sell a stock that lasts until the order is completed, expired, or cancelled. The maximum lifetime of any order is 28 days. An Immediate-Or-Cancel (IOC) order is an order to buy or sell a stock that must be executed immediately. Any portion of an IOC order that cannot be filled immediately will be cancelled. Once your order is complete, you can view your open orders and order history at the bottom of the same page (you can also view the same info on the ‘orders page’). Bittrex Fees Bittrex charges 0.25% for all trades. This is slightly more than other common exchanges like Binance (0.10%). Bittrex does not charge fees for deposits, but charges for withdrawals to compensate for the network transfer fees that are usually built into different coins. Supported Assets Bittrex currently supports around 300 coins. The list includes ERC-20 tokens, DAG based coins and coins of other Blockchains such as NEO and Cardano. Bittrex Customer Support Like the most popular exchanges, Bittrex deals with a large amount of requests and support tickets. However the platform generally responds to questions quickly and keeps the lines of communication open via social media. They also have a dedicated support page where they describe in detail how to use all functions on the site and provide answers to frequently asked questions. When we sent a support tickets we received a reply in just two days. Is Bittrex Safe? The exchange places a strong emphasis on security, requiring 2 factor authentication, identify verification and email confirmation each time you sign in from a new IP address. To date, there have been no major Bittrex hacking incidents from past three years, although users should always beware of individual hacking attempts that can come from or website URLs that resemble Bittrex’s official website address. phishing emails Bittrex API Bittrex does allow trading bots to be linked to accounts using their API keys. Those bots can place limit buy and sell orders. Site Status Bittrex attempts to be as transparent as possible about how well their systems are functioning. On the site status page, users can view status information for Bittrex hot wallets and markets, updated on a 5-minute interval. The page shows the status, block height and connections of each coin listed on the exchange. Pros Highly secured, great user experience and design Site status reports shows that user experience is always a priority Sophisticated support US based Cons Some users have that their accounts were temporarily suspended pending completion of a review. These users have expressed their frustrations online but often haven’t received a response back. As a US based exchange, the company is forced to comply with KYC and AML processes, which may cause it to overreact to activities it deem suspicious. complained Conclusion Overall, Bittrex is a must-have for the typical crypto trader. The exchange provides hundreds of high profile coins, plus a full stack of features for advanced traders and developers, to make traders of every skill level satisfied. They also place a large emphasis on security and usability through their support page. If you’re just getting into trading or are curious to explore alternative exchanges, Bittrex should be a platform to consider. Originally published at cryptopotato.com on July 26, 2018.

Bittrex Exchange Review — Beginner’s Guide

On the web it is common to see this kind of layout when you’re browsing a plethora of content with no discernible structure: Your eye is naturally drawn to shapes you recognize. Our visual cortex can only process so much information at one time and our pea-sized attention spans can’t keep up. Whatever is not recognized is filtered out, and while it appears in your visual field it does not imprint. It’s called a and I’m here to tell you it sucks. masonry layout But the newspaper… In the days of the early mechanical printing columns were used because type blocks had to be manually arranged and later were formed on demand. This was no easy task. As we transitioned to modern printers, columns persisted because it allows more various articles above the fold and works well with advertising. So why do we still use these layouts on the web in the year 2017? For the very same reasons: advertising and loosely related content. If you are deciding whether or not you should use a masonry layout, the answer is almost always no. There is one exception: when you can’t sort your content by order of appeal. The Devil Goes by Many Names: , , , — these are all wonderful implementations of what a masonry layout looks like. And they power many websites because of their ease of use and the features they offer. The problem however, is they aren’t built for speed and deceive the developers using them. Isotope Packery Masonry.JS Bricks.JS In 2016 I was tasked with developing an entirely new React web application for . This is how the website looked before: The Hunt There is no doubt that this grid display is dated, but it’s also really easy to navigate because it’s linear. It flows like a book, line by line. If I could go back and make a better case for that layout, I would. Because masonry layouts are slow… We started with Isotope JS. I’ve used it before in previous projects and it does alright for lighter websites and static blogs. In development I never noticed any performance issues because I running an i7 Intel 3.4GHz processor and 16GB of RAM. When we launched our users were reporting crashes and laggy scrolling. I dug into the library and found the APIs it was hitting were much slower and out of date, causing unnecessary browser repaints. The other problem was Infinite Scroll, another bad user interface pattern we can’t seem to get rid. But that’s a whole other subject. In this case, the infinite scroll and masonry layout were loading hundreds of DOM elements per page and repainting far more than necessary. What good is a masonry layout if your users can’t get past page three on their netbooks and tablets? I combed through many of the masonry layout libraries out there. Against the recommendations of just about everyone I talked to, I knew I had to do the one thing I didn’t want to do. I wrote my own layout engine… Sometimes you have to start from scratch. What we need from a masonry layout is not the same others need. Many masonry layouts have wonderful features like variable element sizing and drag-and-drop. I set out to figure out why some of these libraries were slow. What I found is that many of the features that make them flexible also hurt. For example variable sizing is a huge performance drain: measuring a hundred element size models is expensive. And in some instances a library would use methods that would cause an unnecessary repaint to get the width and height. Another issue is that all of these elements add up and as the page grows, the calculations incur exponentially. Then I looked at Pinterest — the pinnacle of masonry. I wondered how the engineers managed to keep it fast and usable. So here is where I drew the line: Predetermined element height — this made it easier to layout items at the same place every time. Without this the entire layout would need to re-calculate to accommodate a new item. Fixed column widths — percentages are expensive and along with #1 this would save us from unnecessary paints and repaints to slow DOM APIs Render only what’s visible — by reducing the number of DOM elements the browser has less objects to paint on scroll and reflow. The process involved a lot of math and patience — calculating where to place items and how to place them efficiently. For example when an item spans multiple columns it will create a gap if the items above do not align. This was the most challenging aspect because we didn’t want a fast masonry layout with empty whitespace everywhere. All of this had to fit inside a React Component and go with the grain of lifecycle events. So when infinite scroll loads a new page only new items should layout. And what a beautiful React Component it turned out to be. I decided to write this post to document both the frustration and immense pride I felt for this effort. When I reflect on the process and the result — I see some of my best work. Trying and trying, iteration after iteration; the “are we there yet” moments. The voice at the back of my head saying “don’t write a layout engine.” The Result: a fast Masonry layout built in React It turned out to be incredibly performant. On a Chromebook there were no hiccups and rendering was faster than it took for the server to return the next page. I immediately made the component available via (check it out if you want to see what’s under the hood). It’s not available as a package because it’s not “one size fits all” and the last thing the web needs is another masonry library. Github You can see this engine running live @ thehunt.com proceed with caution. There are a plethora of resources available for Flexbox, CSS4 Grids, and performant interfaces on the web. Seek out better user experiences that flow naturally. If you are looking to do it yourself then I would suggest doing your research and eliminating over-engineered features. If you are thinking of rolling your own layout engine: I hope you enjoyed reading this: if you feel the pain of masonry layouts or you’ve been there before feel free to share your experience.

Masonry in React: A Performance Hell

Startups of The Year 2023 Winners: North America 

Microsoft and AOL: How Did This Relationship Come Together?

This will be a continuation of the article: The Evolution of MV* Patterns in Android: Part 1 MVVM MVVM is also known as model-view-binder and was created by Microsoft architects Ken Cooper and John Gossman. Google I/O 2017 introduced architecture components that includes and which facilitates developing apps using the MVVM pattern. LiveData ViewModel Android This approach allows you to connect view elements with phenomena and events of the View model. It can be argued that each layer of this pattern does not know about the existence of another layer. The first and main difference is in the names of the business logic layers: in MVP and its derivatives, it is stored in the Presenter, while in MVVM, this role is played by the ViewModel. Secondly, this is the way the View layer and ViewModel interact. This is complicated by the fact that the obviously does not know about the layer, but still controls it. How can this be? More on this a little further. ViewModel View Layers of MVVM pattern are: This layer is responsible for the abstraction of the data sources. Model and ViewModel work together to get and save the data; Model: The purpose of this layer is to inform the ViewModel about the user’s action. This layer observes the ViewModel and does not contain any kind of logic; View: It exposes those data streams which are relevant to the View. Moreover, it serves as a link between the Model and the View; ViewModel: To implement MVVM, you will need to use or Kotlin , which precisely implements the principle of the Observer pattern and is also consistent with the lifecycle of the View. Learn more about working with events: LiveData Flow LiveData occurs simply through callbacks. View knows explicitly and stores a link to the , which allows us to use its methods. Listening to events ViewModel occur through or . We will always have the current value of our specific widget or the entire View layer on the View layer. Changes to the ViewModel MutableLiveData MutableStateFlow Example: ViewModel class MainViewModel : ViewModel() {  
  
    private val booksRepository: BooksRepository = BooksRepositoryImpl()  
    private val _booksLiveData = MutableLiveData<List<Book>>()  
    val bookLiveData: LiveData<List<Book>>  
        get() = _booksLiveData  
  
    private val _loadingLiveData = MutableLiveData<Boolean>()  
    val loadingLiveData: LiveData<Boolean>  
        get() = _loadingLiveData  
  
    fun fetchBooks() {  
        _loadingLiveData.value = true  
        booksRepository.fetchBooks {  
            _booksLiveData.value = it  
            _loadingLiveData.value = false  
        }  
    }  
} Repository interface BooksRepository {  
      
    fun fetchBooks(): List<Book>  
      
    fun saveInFavorites(id: Long): Boolean  
      
    fun removeFromFavorites(id: Long): Boolean  
      
}  
  
data class Book(val id: Long, val title: String, val author: String) MainFragment class MainFragment : Fragment(R.layout.fragment_main) {  
  
    private lateinit var booksRV: RecyclerView  
    private lateinit var progressBar: ProgressBar  
    private val adapter = BooksListAdapter()  
    private val mainViewModel: MainViewModel by viewModels()  
  
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {  
        super.onViewCreated(view, savedInstanceState)  
        booksRV = view.findViewById(R.id.books_rv)  
        progressBar = view.findViewById(R.id.progress_bar)  
  
        mainViewModel.fetchBooks()  
        observeLiveData()  
    }  
  
    private fun observeLiveData() {  
        mainViewModel.loadingLiveData.observe(viewLifecycleOwner) { value ->  
            value?.let {   
if (it) {  
                    progressBar.visibility = View.VISIBLE  
                } else {  
                    progressBar.visibility = View.GONE  
                }  
            }  
        }          
mainViewModel.bookLiveData.observe(viewLifecycleOwner) { value ->  
            value?.let {  
                adapter.submitList(it)  
            }  
        }    }  
  
    companion object {  
        @JvmStatic  
        fun newInstance() = MainFragment()  
    }  
  
} In conclusion With the right and experienced approach, MVVM simplifies the process of writing tests for code (due to fewer explicit connections), and it can be a slightly less verbose architecture than MVP and its derivatives.

The Evolution of MV Patterns in Android: Part 2

If you’re developing modern single-page applications with Ruby on Rails, you’re most likely using some fancy JS framework for your UI to be updated nicely, without page reloads. And there is really not much you can do without using them, that’s kind of a standard these days… until Rails got Hotwire. With Hotwire you can get fast and responsive web applications, but without writing a ton of Javascript. Well, sounds great, but what is Hotwire? In this article, we’ll go through the basics of Hotwire, as well as build a sample app using it. What options are there for responsive Rails apps? On June 25, 2013, Rails 4 was released introducing Turbolinks. And what are Turbolinks doing for “responsiveness” of Rails? Turbolinks intercept all link clicks and instead of sending regular requests it sends an asynchronous Javascript request (AJAX) to fetch HTML. It then merges the tag of the fetched page and replaces the whole tag of the page, so there is no full page reload. No stylesheets or scripts reloading, which means faster page navigation. But, it still is replacing the whole , not only the changed parts of the page. GET head body body What if you want to reload only the parts that changed? Well, you could use Rails AJAX helpers, when you mark some elements as , it makes those elements send AJAX requests instead of regular requests. And Rails responds with generated JS code, which is then executed by the browser to dynamically update those parts of the page. data-remote='true' GET/POST GET/POST Then, we can get to some JS components on the frontend (e.g. using React) to make an app feel even more responsive. So, the JS component sends an AJAX request and the Rails server responds to it with JSON data. Then, the frontend framework transforms the received JSON to DOM elements and updates DOM to reflect those changes. And it works nice, with the only downside being that it mixes server-side rendering and client-side rendering on a page. Another more traditional way these days, is going all in and using React, Vue, or another JS framework on the frontend for only client-side rendering, i.e. so-called Single Page Application (SPA). With this approach, the frontend is a separate application that sends AJAX requests to the Rails server, and Rails is solely a JSON API. As you probably know, there’s a lot of complexity in building, maintaining, and deploying two separate apps with interchangeable data. But, what if you could build a SPA without all the complexity of building two separate apps and writing lots of Javascript code? Here’s what Hotwire can help you with. What is Hotwire? Hotwire is an alternative approach to building SPA-like web apps, rendering all of the HTML server side using Rails templates while keeping the app fast and responsive. Keeping rendering on server side makes your development experience simpler and more productive. Hotwire name basically is an abbreviation for , which means sending generated HTML instead of JSON from the server to the client. It also does not require you to write much custom javascript code. Hotwire is made of Turbo and Stimulus. HTML Over the Wire What is Turbo? Turbo gem is the heart of Hotwire. It’s a set of technologies to dynamically update the page, which speeds up navigation and form submission by dividing pages into components that can be partially updated utilizing Websockets as a transport. If you ever worked with websockets in Rails, you most likely know that Rails is using ActionCable to handle websockets connection, and it’s included in Rails by default. And Trubo gem consists of: Turbo Drive, Turbo Frames and Turbo Streams. Turbo Drive Turbo Drive is used to intercept link clicks (just like Turbolinks were doing it previously) and also intercept form submissions. Turbo Drive then merges the head tag of a page and replaces the body tag of the page. The same case as with Turbolinks, no full page reload, which may be fast for some pages, but not really as responsive as the 2022 app is expected to be, so you might consider updating only some parts of the pages, not the whole body. Here’s where Turboframes come in handy. Turbo Frames You can simply make a part of a page a Turbo Frame, by simply wrapping it in a turbo-frame tag with a unique id <turbo-frame id="13">
  ...
</turbo-frame> This makes any interactions within the frame to be scoped to that frame. Any interaction within that framne send an AJAX request to the Rails server, and server responds with an HTML only for that frame. Which allows Turbo to automatically replace only that frame on a page. And this does not require to write any Javascript. But what if you want to update multiple parts of the page at the same time? That’s what Turbo Streams can help you with. Turbo Streams When user interacts with an element on the page (e.g. form/link) and Turbo Drive sends an AJAX request to the server, the server responds with an HTML, consisting of Turbo Stream elements. And those are like directions for Turbo to follow in order to update affected parts of the page. Turbo Streams include seven available actions: : append, prepend, (insert) before, (insert) after, replace, update, and remove <turbo-stream action="append" target="target_a">
  <template>
    HTML
  </template>
</turbo-stream>

<turbo-stream action="prepend" target="target_b">
  <template>
    HTML
  </template>
</turbo-stream>

<turbo-stream action="replace" target="target_c">
  <template>
    HTML
  </template>
</turbo-stream> Turbo Streams are using ActionCable to deliver updates to multiple clients via websockets asynchronously. Again, you’re getting all of this w/out writing any of the Javascript code. But even if you need some custom Javascript for any reason (e.g. some animation, datepicker, etc.), Hotwire got you covered here with Stimulus. What is Stimulus? Just like Rails which has its controllers with actions, Stimulus allows you to organize client-side code in a similar way. You have a controller, which is a Javascript object, which defines actions, i.e. Javascript functions. Then you connect the controller action to the interactive element on a page using HTML attributes. The action is then run in response when DOM events are triggered. Let’s create a sample Rails app with Hotwire Now having read all of the above, you might be wondering: how do I work with it? Hotwire is pretty simple to use, all that we need is a standard Rails app and Redis server. First, you need to have Ruby 3 and Rails 7 and Redis server to be installed, I’m not going to cover the installation process of those, but you can easily find any instructions you need based on your platform. So, let’s set up a new Rails app (we’ll be using Bootstrap as css option, just to make our app look a bit better): rails new bookstore --css bootstrap After Rails generated all the needed files, cd into the app directory: cd bookstore Rails 7 initial app has everything we need to start using Hotwire, the Gemfile includes Redis gem, Turbo-rails gem and Stimulus-rails. Make sure that you have Redis server up and running. Redis is required because it’s used by ActionCable to store websockets-related information. The default address and port for Rails to connect to Redis server is set in the config/cable.yml development:
  adapter: redis
  url: redis://localhost:6379/1 Then we can genertate our model, controller and migration, which will be “Books” in our case of Bookstore. It’ll have a string title, description of type text and likes counter as integer: rails g scaffold books title:string description:text likes:integer Let’s fix generated migration, so we have 0 likes by default for any book we add to the db: class CreateBooks < ActiveRecord::Migration[7.0]
  def change
    create_table :books do |t|
      t.string :title
      t.text :description
      t.integer :likes, default: 0

      t.timestamps
    end
  end
end Don’t forget to create a database for our app, run in terminal: rake db:create db:migrate Let’s make books list page the root page of the app, open and add the missing root declaration: config/routes.rb Rails.application.routes.draw do
  root 'books#index'
  resources :books
end Then you should be able to run rails server with command or (which will also watch css and js changes) in your terminal and, when you visit in your browser, you should see something like this: rails server ./bin/dev http://localhost:3000 Let’s change the Book partial to this: app/views/books/_book.html.erb <%= turbo_stream_from "book_#{book.id}" %>

<%= turbo_frame_tag "book_#{book.id}" do %>
  <div style="background: lightblue; padding: 10px; width: 400px;">
    <h2><%= book.title %></h2>
    <p><%= book.description %></p>
    <br>
    <%= button_to "Like (#{book.likes})",
                  book_path(book, book: { likes: (book.likes + 1) }), method: :put %>
  </div>
  <br/>
<% end  %> tells Hotwire to use websocket for updates of a frame identified with , and identifies a frame, which can be replaced with partial on update. turbo_stream_from :book_id turbo_frame_tag To tell Turbo that we want to add each new created book to the start of the books list, and update likes count on each like button click, we need to add following callbacks to file (also let’s add a validation): app/models/book.rb class Book < ApplicationRecord
  after_create_commit { broadcast_prepend_to :books }
  after_update_commit { broadcast_replace_to "book_#{id}" }

  validates :title, :description, presence: true
end The first one tells Turbo to use Turbo Stream for updates on create, and the second one tells to use to replace partial with updates. :books :book_id Then let’s fix the ordering in our books controller and also add the new book variable assignment (so we could create a book from the root path) in : app/controllers/books_controller.rb ...
def index
  @books = Book.order(created_at: :desc)
  @book = Book.new
end
... We should also edit to add our Turbo Streams and Turbo Frames: app/views/books/index.html.erb <h1>Books</h1>

<%= turbo_stream_from :books %>

<%= turbo_frame_tag :book_form do %>
  <%= render 'books/form', book: @book %>
<% end %>

<%= turbo_frame_tag :books do %>
  <%= render @books %>
<% end %> To avoid redirects when we create a new book or update an existing one and stay on the same main page, we need to also edit create and update actions in : app/controllers/books_controller.rb ...
def create
  @book = Book.new(book_params)

  respond_to do |format|
    if @book.save
      format.html { redirect_to root_path }
    else
      format.turbo_stream { render turbo_stream: turbo_stream.replace(@book, partial: 'books/form', locals: { book: @book }) }
      format.html { render :new, status: :unprocessable_entity }
    end
  end
end

def update
  respond_to do |format|
    if @book.update(book_params)
      format.html { redirect_to root_path }
    else
      format.html { render :edit, status: :unprocessable_entity }
    end
  end
end At this point, our bookstore app should look like this: Conclusion Any time you create a new book using the form on the main page, Turbo prepends it to the books list, w/out page reloads. If you open multiple tabs in the browser - it will update all of them. “Like” buttons are also working w/out page reloads and update likes counts for the book in all of the tabs. And all of this with not a single line of Javascript code. How cool is that? This sample application is just a basic example of what you can do with Hotwire in Rails, but you can do much more complex things with Turbo and Stimulus. So if you want to start a new SPA with Rails, think twice if you need React, Vue or any other framework on the frontend, it might be much more productive to give Hotwire a try. There’s a big chance it will make you happy. Also Published Here

Stories, News & Mentions about BOOKLINE

Bookline’s Stories on HackerNoon

Bookline's News & Mentions