Get the most recent info and news about ZipBooks on HackerNoon, where 10k+ technologists publish stories for 4M+ monthly readers.

ZipBooks is simple, beautiful, and powerful accounting software that gives you the tools and intelligence to take your business to the next level. Send professional invoices, automate your billing, and collect payment seamlessly with all major credit cards. Efficiently track your expenses and maintain up-to-date, color-coded records that let you know what’s going on at a glance. Add ZipBooks time tracking, tagging, and team management, and you’ve got a system that just works! ZipBooks combines these tools with data-driven intelligence: smart insights and reports that help you get paid faster, retain customers and save money. It’s like having a trusted advisor at your side every step of the way. From simple to sophisticated, ZipBooks has a solution to fit your needs!

ZipBooks

zipbooks

Other options may be right for your organization, however, such as ZipBooks and its wealth of features, or Akaunting and its support for a whopping 45 languages. In this guide, you can learn about ...

Best Free Accounting Software for 2023

Meet the Winners of Startups in North and Central America

Python is awesome, it’s one of the easiest languages with simple and intuitive syntax but wait, have you ever thought that there might ways to write your python code simpler? In this tutorial, you’re going to learn a variety of Python tricks that you can use to write your Python code in a more and way like a pro. readable efficient Let’s get started Swapping value in Python Instead of creating a variable to hold the value of the one while , you can do this instead temporary swapping >>> FirstName = >>> LastName = >>> FirstName, LastName = LastName, FirstName 
>>> print(FirstName, LastName)
( , ) "kalebu" "Jordan" 'Jordan' 'kalebu' Create a single string from all elements in the list Instead of Iterating each element over the list using for loop and appending each element to the string, you can do this instead. >>> python = [ , , , ]
>>> python_string = .join(python)
>>> print(python_string)
    Python Syntax is elegantly "Python" "Syntax" "is" "elegantly" ' ' Merging two dictionaries Use to combine two sets of update( ) dictionaries a = { : , : } b = { : , : } a.update(b) print(a)
{ : , : , : , : } >>> "name" "Python" "creator" "Guido" >>> "age" 30 "gender" None >>> >>> 'gender' None 'age' 30 'name' 'Python' 'creator' 'Guido' List comprehension to create a specific list Use List Comprehension instead of for loop on a case where you want to create a list from a sequence with certain criteria. You’re going to specify the criteria. For instance in the example below we have created a list of odd numbers in just one line of code (one-liner). >>> odd = [x x range( ) x% != ]
>>> print(odd)
[ , , , , , , , , , ] for in 20 if 2 0 1 3 5 7 9 11 13 15 17 19 Reversing a string in Python You can easily your string with just a bit of slicing as shown below. reverse >>> quote = >>> print(quote[:: ])
God is good "doog si doG" -1 Unpacking a Python List Instead of or reassigning each variable to index in a list, you do this at once by unpacking them as shown in the code below. names = [ , , ] niece, friend, crush = names print( .format(niece, friend, crush))
Melisa Lisa Peace >>> 'Melisa' 'Lisa' 'Peace' >>> >>> '{} {} {}' Iterating over two python list You can actually Iterate over two lists at once without using nested for a loop as shown below >>> books = [ , , ]
>>> pages = [ , , ]
>>> book ,page zip(books, pages):
...     print( .format(book, page))
... 
mabala---> money heist---> GOT---> 'mabala' 'money heist' 'GOT' 200 300 600 for in "{}--->{}" 200 300 600 Using all or any in a conditional statement Instead of writing many if-else statements for your logic, you can actually do this using any and all keywords. all will evaluate to True only if all elements are true while any will evaluate to True if any of the multiple conditions evaluate to True. >>> data = [True, True, False]
>>> any(data):
...     print( )
... 
at least
>>> not all(data):
...     print( )
... 
That if "at least" if "Thats right" 's right Cumulative summing a sequence of numbers In case you want the cumulative sum of numbers to do some plotting, you can easily do this using numpy using its function cumsum () >>> numpy np
>>> factors = list(np.cumsum(range( , , )))
>>> print(factors)
[ , , , , , , ] import as 0 20 3 0 3 9 18 30 45 63 Adding Index to Iterables(list, tuples, etc..) Do this to automatically index your elements within an Iterable >>> students = [ , , ]
>>> student_with_index = list(enumerate(students))
>>> print(student_with_index)
[( , ), ( , ), ( , )] 'Immaculate' 'Prisca' 'Lizy' 0 'Immaculate' 1 'Prisca' 2 'Lizy' import this (Python design principles) One you do this, You will be surprised by seeing Zen of Writing Python code pop up in front of you this import '''
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!''' Hope you find this post interesting, Now share the with your fellow peers that you have made it, . Tweet now The Original Article can be found on kalebujordan.com

Python Tricks Every Developer Should Know

Many of us must have asked this question in various forums and communities — “What are some of the SaaS startups in India?”. While the data is scattered all over, we felt that there wasn’t a single place where one could find this data. There are several hundreds of SaaS companies. This list had just a few dozen startups in 2014 and was a side project on our blog. Thanks to community comments, it grew huge. Now to make it even bigger, we are publishing it on Medium. We truly hope that this helps a bunch of potential startup talent, investors, marketers and many more. This is a continuously evolving list. Please drop in a comment with your SaaS startup or recommendation and I will add it. If you are interested to improve this listing by categorizing startups into product categories or such, reach out to Tejaswi: tej466@gmail.com A _CRM for Small Businesses_ _Revolutionise Customer Support on Social Media_ _Integrated Application Suite for Business & Schools_ _Appointment Scheduling Software_ _Online CRM, Invoicing, Project Management & Timesheets Software_ AgileCRM Airwoot Applane Appointy Apptivo Around.io Social Media Tool for Online Sellers B _Customer Segmentation & Marketing Automation for Ecommerce_ _Online Invoicing System & Online Billing Software_ Betaout Billbooks Build a Bazaar Ecommerce Software to build an Online Store C _Voice Broadcasting & SMS Marketing Software_ _All in One Marketing Software_ _Customer Engagement Management Solutions_ _Human Resource Management System_ _Workflow Automation Software_ _Subscription Billing & Recurring Billing Solution_ _Coaching Classes Management Software_ _Sales CRM for Small Teams_ _Full Stack DevOps Platform_ _Social Work Management Platform_ _Collaborative Spreadsheet Tool_ _Competitive Intelligence for Enterprises and Teams_ _Plug and Play Predictive Customer Analytics Platform_ _Big Data Analytics_ CallHub Canvass Capillary cavinHR Cavintek ChargeBee ClassPro ClinchPad CloudMunch CollaborateCloud CollateBox Contify CustomerLabs Crayon Data Crowdfire Social Media Engagement App for Twitter & Instagram CRMnext CRM Software Solutions for Banking, Insurance, Financial Services & Media D _Easy-to-access data APIs_ _Project Collaboration Software For Small Business & Teams_ _Clinic and Practice Management Software for Doctors_ _Full Stack ERP for E-Commerce_ Dataweave DeskAway DocEngage Dsysh Dquip Lead & Sales Management Software E _HRM Software_ _HR and Payroll Software_ _Business Phone System from the Cloud_ EmployWise Emportant Exotel Explara Online Event Ticketing & Registration Platform F _School Management Software_ _Practice Management Software For CA, CPA, Accounting Firms_ _eCommerce Marketing Automation Software_ _Online GRC Solution for Audit Risk Compliance_ _Big Data Analytics_ _Online Contact Form Builder_ _Online Collaboration, Communication and Real Time Feedback Tool_ _ECommerce website solution_ _Online Customer Support & Helpdesk Solution_ Fedena Firmzen Firecart FixNix Formcept FormGet Framebench FreKart Freshdesk FusionCharts JavaScript Charts for Web, Mobile & Apps G _Cloud Based HR & Payroll Software for SMEs_ _Cloud Based Productivity Platform for work_ GreyTip Gridle GrownOut Automated Referrals Hiring Process H _Platform to code, learn, compete and discover best jobs for developers_ _Platform for programmers to hone skills and for companies to recruit_ _Global Visitor Management Solution_ _Web based Hotel Management System, PMS Software_ HackerEarth HackerRank Happy Visitor Hotelogix Hive Email Based Collaboration Software HRStop Hosted Human Resource Management/Information System I _Online multi channel customer support and helpdesk solution_ Impel Indix Product Intelligence Platform for Brands, Retailers & Developers J _Psychometric Test Online Software_ Jombay JusPay Online Payment Solution K _DIY Ecommerce Platform for Indian SMEs_ _Help Desk and Customer Service Software_ _Business Process Management Tool & Workflow Software_ KartRocket Kayako KiSSFLOW Kreato CRM CRM software for SMBs L _Big Data Analytics Solution_ _Lead Management Software_ _Marketing Automation & Lead Management Software_ LatentView LeadPrime LeadSquared Lybrate Healthcare Platform Connecting Patients and Doctors M _Multichannel Ecommerce Platform_ _Attachments Management System_ _Online Skill Assessment Platform_ _One-stop Technology Solution Dedicated to Events_ _Computational Financial Analytics Platform_ _Cloud-based Training Solution_ _iBeacon Proximity Marketing and Analytics Platform_ _Targeted Marketing Platform for Mobile Apps_ _Software for DMC & Tour Operators_ MartJack MetisMe Mettl MeraEvents MilkorWater MindTickle MobStac MoEngage Moxiter MyOperator Cloud Based Phone System for Small Businesses N Nittio Learn Learning automation for businesses O _Open Source ERP and CRM_ _Sales Force Automation Software_ _PaaS-Based Cloud Application Development Platform_ _Cloud Based Accounting Application_ Odoo OpusViz OrangeScape Owlgrin Ozonetel Cloud Communication Application Provider P _Telecom Operations Management_ _An Online Gamification Platform_ _SMS & Voice API to Build Apps_ _Real time Customer Analytics_ _Point of Sales System for Restaurants_ _Online Medical Practice Management Software_ _Cloud Based Physician Practice Management Solution_ _Online Accounting Software for SMBs_ _DaaS Provider for Large-Scale Data Needs_ Pervazive Playlyfe Plivo Plumb5 Posist Practo Praxify ProfitBooks Prompt Cloud ProofHub Online Project Management Software Q Qubole Big Data as a Service (BDaas) Platform R _SEO Management Platform_ _Online Accounting & Billing_ _Online Recruiting and Resume Management_ RankWatch ReachAccountant RecruiterBox Relecura Platform for Patent/Portfolio Analysis & IP Business Intelligence S _Web Based CRM Software Platform_ _Social Commerce Store Builders_ _Content Protection and Anti-Scrapping Solution_ _ECommerce Store Building Platform_ _A Social Media Monitoring & Analytics Platform_ _Social Media Marketing and Monitoring Platform_ _Mobile-first ECommerce Platform_ _HR & Payroll Management Software_ _Help Desk Software_ SalesBabu SellMojo ShieldSquare Shopnix Simplify360 SocialAppsHQ StoreHippo sumHR SupportBee Synergita Talent and Performance Management Software T : _Create chatbots with no Programming Knowledge at all_ Tars Typito : Make video editing simple and accessible for all U _Ecommerce Product Discovery & Recommendation Platform_ _Ecommerce Management Software & Fulfillment Solutions_ _Solving Mystery Of App Uninstalls_ _Social Media Analytics_ Unbxd UniCommerce Uninstall.io Unmetric UsersDelight Customer Engagement and Growth Tool for Website & Mobile App V _Free People Search Technology_ _Actionable & Intelligent Video Analytics Suite_ _Viral Marketing and Customer acquisition Platform_ Vibe Vidooly ViralMint VWO A/B Testing Tool and Conversion Optimization Platform W _Customer Engagement Tool for Websites_ _ERP School Management and Administrative Software_ _How To Guides for Websites_ _Hosted CRM for SMEs_ _Ecommerce Software to Build an Online Store_ WebEngage Web-School WhatFix WindCRM WorldMart workXmate Cloud ERP Software for SMEs X Y Z : CRO Software with A/B Testing, Heatmaps, Funnel Analysis & Form Analytics. _ECommerce Platform for SMBs_ _Cloud Based Human Resource Management Software_ _Cloud Based Accounting Software_ _Enterprise grade solution for shortening of URLs, branding a domain & gathering statistics_ Zarget Zepo ZingHR ZipBooks ziplr Zoho Online Business, Network, and IT Infrastructure Management Applications 0–9 99tests Software Testing Community

Massive List of 100+ SaaS Companies in India

This will be a continuation of the article The Evolution of MV* Patterns in Android: Part 2 MVI MVI (Model-View-Intent) is an architectural pattern that is part of the Unidirectional Data Flow pattern family - an approach to system design in which everything appears as a unidirectional flow of actions and control states. Unlike MVVM, MVI assumes only one data source (single source of truth or SSOT). MVI consists of three components: logic, data, and state (Model); UI layer displaying the state (View) and intention(Intent). For example, if the user clicks on the “Respond to request” button, the click is converted into an event (Intent) necessary for the Model. In this formula, a request will be made to the server, the resulting result will update the screen state. The UI layer, in accordance with the new state, creates a button and displays text stating that the application has been sent. Let's move on to the example and the code. The example will show a simple method. Let's take an example from previous articles and the first thing we will write is states and events. sealed interface Event {  
  
    object FetchBooks: Event  
  
}  
  
sealed interface State {  
  
    object Loading: State  
  
    object Empty: State  
  
    data class Success(val books: List<Book> = emptyList()) : State  
  
    data class Error(val errorMessage: String)  
  
} Let's move on to the ViewModel. Here we will also use , but keep in mind that you can use Kotlin . LiveData Flow This is what the MainViewModel looks like now: class MainViewModel : ViewModel() {  
  
    private val booksRepository: BooksRepository = BooksRepositoryImpl()  
    private val _state = MutableLiveData<State>(State.Empty)  
    val state: LiveData<State>  
        get() = _state  
  
  
    fun event(event: Event) {  
        _state.value = State.Loading  
        when(event) {  
            Event.FetchBooks -> {  
                booksRepository.fetchBooks {  
                    if (it.isNotEmpty())  
                        _state.value = State.Success(books = it)  
                    else  
                        _state.value = State.Empty  
                }  
            }  
        }  
    }  
  
} Changed 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.event(Event.FetchBooks)  
        observeLiveData()  
    }  
  
    private fun observeLiveData() {  
        mainViewModel.state.observe(viewLifecycleOwner) { state ->  
            when(state) {  
                is State.Empty -> {  
                    progressBar.visibility = View.GONE  
                }  
                is State.Loading -> {  
                    progressBar.visibility = View.VISIBLE  
                }  
                is State.Success -> {   
                    progressBar.visibility = View.GONE  
                    adapter.submitList(state.books)  
                }  
                is State.Error -> {  
                    Toast.makeText(context, state.errorMessage, Toast.LENGTH_SHORT).show()  
                }  
            }  
        }  
    }  
  
    companion object {  
        @JvmStatic  
        fun newInstance() = MainFragment()  
    }  
  
} As a result, we have one input where events are processed and an output with a state. Pros State objects are immutable so it is thread-safe. All actions like state and event are in the same file so it is easy to understand what happens on the screen at one look. Maintaining state is easy. Since data flow is unidirectional, tracking is easy. Cons It causes a lot of boilerplate. High memory management because we have to create lots of object. Sometimes, we have many views and complicated logics, in this kind of situation become huge and we might want split this into smaller ones with extra instead of just using one. State State StateFlows

Evolution MV* Patterns in Android: Part 3

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

In this article, we will analyze the evolution of presentation patterns such as MVC(Model-View-Controller), [MVP](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93presenter#:~:text=Model%E2%80%93view%E2%80%93presenter%20(MVP,mostly%20for%20building%20user%20interfaces.&text=In%20MVP%2C%20the%20presenter%20assumes,is%20pushed%20to%20the%20presenter.)(Model-View-Presenter), MVVM(Model-View-ViewModel), MVI(Model-View-Intent). The problem of understanding the architectural approach in mobile development, in my opinion, lies in the abstractness of the architecture itself. Each developer has his own vision of how to correctly implement a particular pattern. And what are representation patterns for? structure the code and separate it into layers write maintainable and testable code Let's move on to what Model and View mean: is the data layer. Usually, it can be a and it talks to the database and the network. Model Repository is the display level. On Android, this would be , , or and should ideally be as dumb as possible. View Activity Fragment Custom View MVC This is the simplest pattern in , where the main business logic is contained in the Model class, and the View and Controller are implemented by the Activity and Fragment. Android Below is a diagram and sample code: Let's write our 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) MVC release example: class MainFragment : Fragment(R.layout.fragment_main) {  
  
    private lateinit var booksRepository: BooksRepository  
    private lateinit var booksRV: RecyclerView  
    private val adapter = BooksListAdapter()  
  
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {  
        super.onViewCreated(view, savedInstanceState)  
        booksRV = view.findViewById(R.id.books_rv)  
          
        booksRepository.fetchBooks {  
            adapter.submitList(it)  
        }  
        }  
  
    companion object {  
        @JvmStatic  
        fun newInstance() = MainFragment()  
    }  
} Everything seems to be fine, but at first glance, over time, our code will grow and it will be difficult to maintain it. MainFragment And here there are certain disadvantages: difficult to write tests; code becomes more difficult to maintain over time; code is more difficult to read; MVP This approach allows you to create an abstraction of the view. To do this, you need to highlight the view interface with a specific set of properties and methods. The presenter, in turn, receives a reference to the implementation of the interface, subscribes to view events, and changes the model upon request. - a layer between View and Model. The View passes the events to it, and the Presenter passes them on, if necessary, calls the Model, and returns the data to the View for rendering. Presenter Presenter features: Two-way communication with the presentation; The View interacts directly with the Presenter by calling the appropriate functions or events of the Presenter instance; The Presenter interacts with the View by using a special interface implemented by the View; One Presenter instance is associated with one display; Cons Cyclic dependency between View and Presenter; The presenter provides methods to handle the View lifecycle; Bloated View interface; Difficulty maintaining state; MVP example. Creating the MainView interface: interface MainView {  
  
    fun setBooks(books: List<Book>)  
    fun showLoading()  
    fun hideLoading()  
    fun showError(message: String)  
  
} We create the MainPresenter class and pass it into the MainView constructor: class MainPresenter(private val view: MainView) {  
  
    private lateinit var booksRepository: BooksRepository  

	init {  
	    booksRepository = BooksRepositoryImpl()  
	}

    fun bind() {  
        view.showLoading()  
    }  
  
    fun fetchBooks() {  
        booksRepository.fetchBooks {  
            view.hideLoading()  
            view.setBooks(it)  
        }  
    }  
  
} And finally MainFragment: class MainFragment : Fragment(R.layout.fragment_main), MainView {  
  
    private lateinit var booksRV: RecyclerView  
    private lateinit var progressBar: ProgressBar  
    private val adapter = BooksListAdapter()  
    private lateinit var presenter: MainPresenter  
  
    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)  
  
        presenter = MainPresenter(this)  
        presenter.bind()  
        presenter.fetchBooks()  
    }  
  
    override fun setBooks(books: List<Book>) {  
        adapter.submitList(books)  
    }  
  
    override fun showLoading() {  
        progressBar.visibility = View.VISIBLE  
    }  
  
    override fun hideLoading() {  
        progressBar.visibility = View.GONE  
    }  
  
    override fun showError(message: String) {  
  
    }  
  
    companion object {  
        @JvmStatic  
        fun newInstance() = MainFragment()  
    }  
  
} What's going on? MainFragment, aka View, in the method, creates a Presenter instance and passes itself to the constructor. onViewCreated() Presenter, when created, explicitly receives a View and creates an instance of the Repository The Presenter accesses the Repository fetchBooks method. Repository receives and gives data to Presenter. Presenter calls View and passes the list of books

Stories, News & Mentions about ZIPBOOKS

Zipbooks’s Stories on HackerNoon

Zipbooks's News & Mentions