13. Monolithic to Modular | John Daniel


modular

DX, Scratch org, and 2nd generation packaging form the new paradigm of Salesforce development. John Daniel shares how he helps large firms transfer the existing codebase from monolithic to the new modular way.


Main Points

  1. Quickly recap what John shared in his video: Architecting Unlocked Packages in Your Salesforce Org
  2. What values do both DX and unlocked package features bring to John’s splitting solution journey
  3. What values do scratch org feature bring to John’s splitting solution journey
  4. Discuss how to transition to using scratch org
  5. Manage package dependencies by DX plugins
  6. How did John’s journey start? How was the team and management’s attitude at the beginning
  7. John’s recommendations for teams that want to take the same journey: splitting solutions into modular.
  8. What types or sizes of business should take this journey?
  9. What updates John have had after his video: Architecting Unlocked Packages in Your Salesforce Org

Links


Contact Me

If you enjoy this podcast, please reach me out to let me know your thoughts or simply say Hello. My (Xi’s) contact info:

Take care, until next time :)!

Transcript

AI-generated, unedited.

[00:00] Thanks for tuning into the Salesforce Way podcast, episode thirteen.

[00:15] Salesforce Way is the podcast meant for Salesforce developers. In each episode, I invite a guest to share the inside of a topic. Our goal is to at least slightly help you, not only in the Salesforce world, but in general, become a better software engineer. If you like our content, consider to follow us by the RSS feed or in iTunes, so you won't miss any updates. In addition to the podcast, there is a newsletter where we share more useful information, such as other chats with the guests, good developer videos, learning courses, mistakes to avoid, and so on and so on. If you are in the journey to become a good software engineer, just like me, I'm confident that you will find it home after subscribing to the newsletter. So the RSS feed, the iTunes link, my Twitter, the newsletter can be all found at our website SalesforceWay.com. Now let's start the show, shall we?

[01:33] Software industries moving fast. The Salesforce classic org-driven model no longer keeps up with the modern software development paradigm. Let's face it, org-driven is ancient, slow, stubborn, and error-prone. Luckily, Salesforce is aware of this issue and has introduced the new paradigm to remedy it. It's the tooling combination of DX, Scratch Org, and the second generation packaging. This new paradigm is source-driven, modular, and fully aligned with the industry best practices. In this episode, John Daniel joins me to share his invaluable experience on helping large firms to transition Salesforce code bases from the old happy soup way to the new modular way. As usual, we discuss why, how, and what. If you need more technical information, I'd encourage you after listening to us to check John's videos linked in the show notes.

[02:52] Hello, everybody. This is Xi Xiao. This is yet another episode of Salesforce Way podcast, and today I'm so happy to sit together with John Daniel to talk about a topic. The topic name is splitting Salesforce solutions into modules. I was so excited the first time when I see the video that John explains how in Salesforce world we can really split the Happy Soup solutions into small modules. So that's the also the reason I invited John today here to be the guest and share his experience. Hello, John. Hello, Xi. Would you mind to introduce yourself a bit? Certainly, certainly. First of all, thank you very much for the invite. I'm honored to be here. Again, my name is John Daniel. I'm currently the director of platform architecture for a Salesforce partner named Rootstock Software. My background is I've been in IT and development and architecture for 24 years now, somewhere in that range. I've been involved in other technologies, Java, Oracle, J2E, enterprise development, and about 10 years ago, I switched over to Salesforce. In that time, I've worked for ISVs and partners, and I was the

[04:22] architect of a law firm, large law firm, at one point, and now I'm here at Ridstock. So. Great. I know you have a lot of great experience in Salesforce world, and you're a person who are willing to share your experience, which which is fantastic. Well, too many people have shared their experience with me, so it's only right that I give back.

[04:49] Yeah, and also definitely, you're one of the guys who have a lot of Salesforce certificates as well. I just wonder for you guys, like I understand from your LinkedIn profile, you have you have more than fourteen certificates at the moment, right? Uh, yeah, it's either or even more than that. Yeah, so I'm current. I'm. Sales Cloud, Service Cloud, the Platform Developer One and Two certifications, Platform App, and I have almost all of the Technical Architect Designer certifications, and I have one more to get, and then I'll go to the review board to get my CTA. So, oh, okay, good luck for that. Thank you.

[05:31] Yeah, for our session, I wanted to actually split it into two. That's the modules. The first part is that the you have talked a lot in your architecting unlock packages in your Salesforce work video, which was recorded last year in Trailhead DX session in March, right? That's two thousand and eighteen. Yeah, so that video link we were putting our show notes for our listeners to to to watch. It has a lot of insights over there. So I have watched multiple times. So I still want to. Take some look when when you talk about how to handle the the dependency injection. That part I still don't quite get. But here we will spend five to ten minutes only just to quickly go through the journey you have you have gone through and make sure our listeners understand what we're talking about. And then the second module in our this session is that I want to have a quick discussion with you to talk about how we can govern a project and a team who want to take the same journey as you did. So how we make sure the final result is as expected and has a success story. So that's something you haven't talked much in your video, but I think it's also super important. How does this schedule sound for

[07:01] you? Absolutely, sounds good. Okay, so I will start talking. So you correct me if I made any mistakes, but I just want to quickly go through. So I understand in your journey, the Salesforce org is kind of like a medium to large size. And you said there are like more than six hundred Apex classes, thirty-six Apex Exchange packages, and eighty data S object, like like the custom object created. And in the full in the team, you have three full time programmer. Let's say at the beginning only two full time, and then the team hired a new one joining, right? So that's like the size of the work you were working on, and back in two thousand sixteen, you heard about the new DX and the second generation packaging. So the company wanted to give it a try and shifting to this new modularized way to split the solutions and do it in a modern fashion for the solution development. But it took some months for the whole team to see how the environment can be splitted. So there were a lot of discussions, a lot of tryouts, and you guys defined like so: you have a custom applications, you have enhancements of the existing installed managed packages,

[08:31] and you have used the open open source libraries like the Apex Common, Apex Mock. And you have, of course, third-party services and integrations with other environments. So those, like big topic, kind of allows you guys to start to put the metadata into certain boxes. So categorize them into different, you know, boxes. I think that's what you guys started from, very much so. Is it so? Okay. Hopefully, I didn't make any mistake. Um, and then of course, uh, during the time. The DX and the packaging wasn't so mature, and you get the information from Salesforce that we still need to wait, so we cannot use it directly. So the team started to, you know, rename the metadata. For example, put some prefix so that the the metadata falls into certain packages. And when the DX and packaging feature become mature, then you can quickly start to, you know, just organize them into the corresponding packages. Absolutely is. Is it like this? Okay, I try to go it through to make sure I really understand the thing, and and then fast forward to maybe two thousand six seventeen, the team started to use Jenkins

[10:01] continuous integration. And since you you you guys started to ah make ah create the packages, and you know there are two styles of the still the building and the development job still existing. One is the the the packages that you guys have already created, and the and the other side is the remaining unpacked code. So the Jenkins have to handle both two streams simultaneously. Right, exactly. That's a that's quite an interesting um experience to me. Usually, you know, for works they don't do two pipeline. Deployment, but I think that's a specific case for you. You have to do that since you are doing the the packaging stuff. Um. Yeah. Definitely. It's. I agree that they don't normally do two streams like that. But in this case, it's actually shift the arrangement. They're they're not parallel streams, but the the CLI the DX modules are streams that are. Upstream, for lack of a better word, or or before the happy soup stream. So they feed the artifacts from those CLI streams feed into the happy soup overall process. And so you install the you install the packages that you've just created, and then you install the remaining bit of happy soup unpackaged code to get a see if that's working. So, yeah. And during

[11:32] the time the team starts to create the package, there is one unique new challenge pop up. That is the inner package communication, right? So we we now split things into different packages, but how to make sure they still can communicate one with another? That was like one challenge you shared in the video as well, and you also shared how you tackle that problem, right? So I think that's definitely one great point. If some other listeners, ah, later need to go through the same journey, so those caveats, think we all need to pay attention to. Absolutely, absolutely. And at the end of the video, you said the final result it would be like thirty packages in the end, right? Yes, exactly. So that's kind of a long journey, as as I understand. It won't happen in several months. Yes, it'll all it'll always be a long journey. Okay, so this is the whole story that I understood from your video. So you have done a lot of things, but now I want to start ask you some questions that has not been covered in your video. Okay. So the whole thing, do we really need DX and the unlock packages? Because I'm still new to Salesforce. I'm here for only one year, and most of the things I've used the Happy

[13:02] Soup way, or just the first generation package, this unmanaged package. I sometimes also use that. But what the DX and the unlock pack to really bring values for this journey for your mission? Could you let us know? Yeah, it's it's a lot of different things. I mean, you know, the traditional Salesforce development. You know, it's been the paradigm's been around for 15 plus years, and we've we've had a single environment, a single org that had all of the metadata dumped into it. But it's it's created it in some respects. It's created some bad habits in the world of Salesforce in that you know that there is no clear demarcation of. Certain applications within the org. All too often, we've treated the Salesforce org as its own single application, as its own single unit. But the reality is, especially in in medium class customers. Medium-sized customers to large enterprise customers, it's it doesn't become necessarily an application, but rather an entire platform that hosts lots of different applications. And so, if you think about the paradigm in that respect, you you quickly realize that it's difficult to segment one application from another, and so then it becomes. You know, bad habits like circular dependencies, where one,

[14:32] where object A depends on object B, which depends on object C, and and C depends on object A, and so that makes complicated issues around deployments. I mentioned that you know our DevOps process back at the law firm, and and I've seen it in other environments that I've been in as well. I mean, the DevOps process just to move code from a single Development place, whether it be by change set or by Ant-based deployment, Apache Ant-based deployment, it can be very cumbersome, very complicated. You've got to make sure that you get all kinds of account for all the different pieces of metadata. And because they're not grouped as a single unit, it becomes difficult to understand what do you want to push forward to the next environment, and and what do you what needs to stay behind? It just it becomes a very huge logistical nightmare, and we lose a lot of time as Salesforce developers grappling with those kind of questions. You know, when you've got, I guess some of the other reasons. That we went down this path, you know. Again, it was the confusion around the metadata dependencies. It was we had we had an issue with onboarding. Onboarding new developers was problematic because, again, in a very large, unorganized codebase. The simple question is, where do you begin their training? Where where do you focus them? And you know, all too often it relies on a couple of key people who have very in

[16:02] depth. Tribal knowledge, if you want to say that, and you've got because it's difficult to document such a monstrous large codebase. So you know one of the appealing factors of DX and and unlock packages and the second generation packaging was that you know we would be able to segment our codebases a lot easier and focus new developers only on a single module versus several modules out there. You know, you you talk about traceability and auditability throughout the development process. So you've got. Be some sort of ticket system, some sort of requirements system. Call it Jira or Rally or whatever system you're using. You know they they put out a a feature enhancement or a bug fix request, and then you've got to you've got to have. A mature development shop needs to have some sort of traceability from the point where those tickets are made all the way to the deployment process. We need to know what commits were made to, what development changes were made for this rally ticket, and it was bundled into this particular release. And so when this release went to testing, we knew that this rally ticket was being satisfied. And then when that version makes it all the way to production. You know, later on we can see that if there's a problem, we can understand what tickets were involved with that type of with that release. That

[17:33] was very difficult before because. Again, there's very little linkage between the movement of metadata through the environments to what actually is prompting the need for the change to begin with. Whereas, you know, if you get modules and you have versioned artifacts that contain the metadata, and and the artifact itself becomes or the module becomes the the mechanism to push the code and transition the code through the environments, it's a whole lot easier to trace through from that perspective. So those are definitely you know key concepts throughout any kind of IT organization. It's just we haven't had that before now, really, in the Salesforce world. We talk about the DX and the Unlocking Package. How about the Scratch Org? I know Scratch Org somehow is linked with DX and the Unlocking Package to development. And in your video, you said by the time when you start to you know introduce this new development process. Your colleagues hated you, because you want to refresh the full copy sandbox UAT, and you want the the developer sandbox to be refreshed with even shorter frequency. So why was that, and what benefit does it bring to us? So within this the the classic Salesforce development paradigm, you've always had. Of course, your production org. You've always had various types of sandboxes,

[19:03] and what? You know you would have a full copy sandbox that would typically be your UAT or regression testing environment, and then you would have what are called developer sandboxes. I've seen organizations go usually one of two routes. They usually adopt the paradigm where they put all the developers into a single sandbox. And so a single environment, a single or Salesforce org, and all the development is done there. There there are issues with that type of an approach. You know, you might have a developer, two developers, each working on the same Apex class, and that's going to be problematic because whoever commits their changes last. That's the change that goes. They override, they override the um their predecessors' changes and commits. So all too often you get problems where oh my changes, developer days changes have vanished and nobody knows where they are, because again the the paradigm is the org is the source of truth, not source control. Source control inherently allows you to have multiple streams, and then when you do pull requests or some sort of merging operation to a central stream, you can recognize when the developer A's work and developer B's work has to be blended together and stuff like that. So, you know, when you have a single developer. Or a single org for all developers,

[20:34] that you just run into all those kind of problems. I've seen other organizations take the opposite paradigm where they set up a sandbox for every developer, so each developer has their own sandbox. And again, but those sandboxes have been spun up from prod, so they already have some amount of code in them. I've seen ISVs do the same thing where they spin up developer edition environments. And they very much want to use source control as the change mechanism. the The issues that those guys would run into are things like, well, how do you get the developer editions or or the single sandbox orgs a hundred percent accurate and a hundred percent sterile, a sterile development environment, so that the only thing that's going in there is the source code from say get a Git repo, GitHub or something like that. And you know I've seen organizations go to great lengths to manage that process, to provide data for those environments, and it I mean it just increases the DevOps cycle tremendously. So you know you've got issues like those developer edition sandboxes or may stay around to for a long time. And so when I came to like a law firm, I mean they they definitely had they they had not refreshed the environment in quite in quite some time. In that the problem was they didn't understand what code was in there that was throwaway, what code that was

[22:04] in there which was. Experimental, but didn't make it, and and and is is obsolete now. And then one of the one of the very first things I did when I went to that law firm was get them out of a jam where they we had to identify only the changes that needed to be migrated to the next test environment and eventually get ready for the production release that was only a month away. And so those, you know, without kind of any kind of visibility into what changes are going on, again, there lots of people, lots of consultants or lots of companies will adopt things like spreadsheets, manual spreadsheets, documenting exactly the metadata components, so they know what to put in the next change set. Scratch orgs are beautiful because scratch orgs cannot live forever. Because of that, it forces the developers to think and say, "Okay, I need to make sure that any of my changes are copied locally, and and put and checked into my source control." That paradigm shift right there has been has been long overdue in the world of Salesforce development. And so yes, I was so excited about it because I had a mechanism that forces the developers to think about moving the source of truth out of the orgs and moving the source of truth over to the to the source control repos.

[23:23] Hey, it's she here, your host. I really appreciate you listening to the show. If you enjoy our content, don't forget to go to our website, check the show notes of the episode, which contains the links to the points we just discussed in the show. Those are the things we consider important, but don't have time to cover in the talk. Oh, by the way, I do also suggest that you subscribe to our newsletter where more information is shared constantly. So after listening to this episode, do head out to our website SalesforceWay.com and find more useful information over there. Now, let's get back to the show.

[24:13] It's kind of interesting coincidence here, is um, because I'm new here in Salesforce world, and when I start to introduce you know scratch off to some of my colleagues or or coworkers. They don't quite get the idea of using Scratch Org, and Scratch Org has its certain limitation. I'm not exactly sure about that. There's certain functionality that works in Dev Static Sandbox, but does not work in Scratch Org. So, so they always telling me, "Don't use that." So time is the money. Let's still stick to the old way. So you know that's something I cannot easily argue with them because I'm lacking of experience and I cannot take the full responsibility if the project fails due to some, you know, technical limitation. But I'm still trying to exploring the scratch org and whenever possible and whenever it's like a fresh new project with only one to two developer, I always start to encourage. The admins plus the developers to to give it a try, so that's what I can do so far. And you and you're not alone. I've heard those stories. the the the reluctance to transition to scratch orgs. I mean, first of all, utilizing scratch orgs alone is not the answer. Scratch orgs by themselves. Are not a viable option unless you have the the source control at

[25:43] a mature state where it represents the state of the org and information like that. And then there there there are some DevOps processes that you have to figure out. You know, it's the the DX works, but it works in in combination with all of these different features of the DX world together. The one in isolation barely work, um, rarely works from that perspective. And you know, and it makes, and I hear what you're saying. I mean, a lot of consultants, especially out there, they have they're on a fixed budget. They have a fixed amount of time to set of hours to work with. They've got to get the feature in there. They have. Oh, they've done it the traditional way. They know how to deliver in the traditional way, and it requires an investment on their side to learn. Take the time to learn how the best utilize the DX infrastructure to deliver their solutions to the end customers, and still do it on budget. And so it's, I mean, whether actually whether it's an ISV or a consultancy, there's going to be a level of investment of time to learn the new paradigm. And so, yeah, your your story is definitely one that's common out there. Okay, good to know about that.

[26:57] In your video, you talk about the package dependency management. You said you were waiting for a single command line in DX so that we can install all the dependent packages. So, was that already come true, or you are still waiting for that? No, we we created a custom. I mentioned in that video that they had announced the the ability to create your own custom plugins. For the DX command line, and we went out. We have set up. There's actually Fabian Talent of France created the plugin. He and I worked on that, and then Rootstock has created our own version of that plugin as well. And so both of them are available. And they do rudimentary functions to you know read the project JSON, read the dependencies in there, and it just it becomes a step saver to set up your scratch org and install all the dependencies in there. So, so the the two repo you mentioned that they are open source or not? One of them is open source. One of them is about to be open source. Oh really? Okay, maybe you can share me the at least the first one. I'll put in our show notes and let the the listeners. And also the second one. Whenever it's already open source, I think you you will yell out in Twitter. Then I will get that link as well. Absolutely. Thanks very much, and just to make sure, I I fully understand the dependence management. The issue

[28:27] is that when we spin up a scratch work, we need to install the dependent managed package or a managed package just to make sure my own solution works. So my own solution depending on multiple packages, those things are hard to install at the moment into scratch work. That's a problem, right? Yeah, I mean, I wouldn't say it's hard. I think it's more tedious now, and these plugins sort of, you know, remove some of the tedious nature out of it. Oh, yeah. And these plugins can install them in sequence, right? You define the sequence, and then you go to the maybe in the JSON file you mentioned, and then or or the project file, and then fetch all these needed packages, right? That's that's how how it does. Okay, I got it. Now let's shift our gear to the other side, which is governing the the team and the project. So it's a fantastic journey you have gone through, but how originally you convinced the team, the management, to really go down this road? All right, um. In my case, when I was when I was at the law firm, I was the lead architect there, and the development team was fairly small. We talked all the time. We were in contact, and we realized the state of affairs for our codebase.

[29:59] In general, just before we had heard about DX, we were trying to bring better organization to our codebase, and we just knew that whenever we did any type of feature enhancement or or bug fix, that we would go ahead. And make any changes in that local section of the codebase, so that we would just slowly start to refactor our codebase to the techniques that were outlined by things like Dan Appleman's Advanced Apex Development Book or Andy Falsitz's Force.com Enterprise Architecture Book. And you know I'm talk about the Apex Common, ApexMocks frameworks, and so at that time we were starting to refactor our code base to go that direction. And so we were doing it not necessarily as an official project, but it was sort of like under the under under the radar, so to speak. So, so you mean at that moment the code base doesn't use the Apex Common and Apex Mock yet? Correct. Correct. Wow, that's a big shift. If you want to apply that into the foundation of all your code, and and the developers that I had at the time were all, except for one of them, we were familiar with, and had used those libraries in previous jobs as well. Personally, I used to work for Financial Force, so I learned firsthand

[31:30] the value of those libraries, and it didn't make sense. To long term to have a code base without those kind of libraries and separation of concerns, and so so when DX was announced and you know it was you know the promise of source code is the truth and the ability to segment things out it just if. It just made logical sense. It was a no-brainer for us. We were just like, we're going this direction anyway. This allows us that much farther. And so we just began this refactoring effort. Again, under the radar. Management at the law firm didn't, to some degree, didn't even know what I was talking about. Okay. And so, you know, we we wanted to make our lives better. We, the developers, and so we just went ahead and started doing this these best practices. And so that's about as far as management had visibility to it. They just knew that we were continually working to implement better and best practices. And and so when the packaging became so that was what was that so that was like the fall of 2016 so October. Is when we really started doing that effort, and so we spent the better part of a year refactoring our code bases, and then in what was it two thousand seventeen at Dreamforce they announced unlock packages, and we were able to

[33:00] slide a lot of slide of a lot of our code base, at least the base pieces. Into packages very quickly because it was all the the heavy work is not so much putting things into packages. The heavy work is getting your code organized in a systematic way. And when you have a code base that is organized in a systematic way, you can do all kinds of things very quickly. One of the one of the biggest issues that people struggle with out in the community is that they don't tackle the refactoring and the organization aspect of the the code base initially. They just want to move straight to unlock packages. And DX, and they they struggle sometimes because they have difficulty breaking those their code bases up because of among other things circular dependencies and stuff like that. So it becomes a struggle.

[33:51] So I think for our listeners, there are many teams waiting to you know take the same adventure or journey as you did. Do you have any recommendations to them? What they should prepare in advance before they do this, like any trainings to the team, negotiation with the management, vision set, all these things. Do you have any recommendations? Yeah, I mean.

[34:17] Yeah, I mean the the management question. I've so I'll say it this way. I'm I'm currently on. My third codebase. So I've transitioned to Rootstock. I'm in the process of transitioning the codebase to Rootstock, and I'm overseeing a lot of our larger clients. And in one client in particular, I'm overseeing their transition to DX, and I'm helping them along with there. And so I'm seeing I'm on my third codebase to transition. This the last two codebases that I've been working on. It has involved. More management conversations. I think the key things are to make management aware that you're going to start a process to.

[35:08] You know, created better, more organized code base and more maintainable code base. So it's it's the same arguments that we've always had to make to as far as value proposition to management. You know, they've got to trust us enough to understand that we are going to spend a little bit of extra time. It's going to it's going to be an investment. It will improve our our delivery process, our time to market process a whole lot better down the road. But it will not be something that we can make a quick change to, and you know, depending on how far you take it. I mean, if you take it as far as as we did with, you know, implementing these open source frameworks and and properly laying out separation of concerns. And and and layering your application, you know, there's a lot of synergies that happen. A lot of ease, a lot of the codebase becomes far more nimble and able to react to business demands. We've seen that time and again. So there's definitely that negotiation you have to at least make management aware. For your development team, it is about education. One of the one of the trans code transitions I've got right now. I have I one I've spent educating one team for the past six months, and another one I'm just starting to bring them up to speed on on the basic concepts of DX. So, you know, one of the transitions is simply the transition in learning

[36:38] about the new IDE that Salesforce is working with, which is the Visual Studio Code. For for you know a decade or more now, we've been working off of the Eclipse-based Force. com IDE, and Salesforce's son is you know stopped support for that. And developers need to start doing that kind of a transition now. I mean, you don't have to use VS Code only on DX projects. You can use VS Code now on classic type development with sandboxes and and that type of things. So, starting your developers to transition into these newer concepts.

[37:15] Things like the Trailhead modules are a good way to get the team starting to get at least familiar with the basic concepts. There is, you know, in our case, you know, we've again been using the Apex Common and ApexMocks frameworks, and the Force DI frameworks is another one that we've been using of late. And there's a lot of there's a lot of blog articles, a lot of some videos, a lot of different material that we've been getting our developers to to read and digest and watch and stuff like that, just so that they can understand a new paradigm that we're talking about. That they may not have been used to before, and so it's a it's a complete different way of thought thinking as far as how you lay out your code, and lay out your code is so many different things. But that's that education that you need to start working with, or getting your team ready for. The other the other piece is I guess you know I talk about it in in this video from Trailhead DX you know identify the applications that you want to identify where you want to go, you know identify the modules that you're that you want to do and then from that identification figure out how they'll be dependent on each other. And then basically, my advice is to tackle the the the base of that dependency tree that you draw. So tackle that piece first, and slowly work up through and into the the downstream dependencies or the branches of

[38:45] the dependency tree, whatever however you want to phrase it. Start with that, and so and and pull that code out to its own module into its own project, and slowly bring that process. To where you perfect that process and you take it away from the happy soup codebase and stuff like. So you you basically siphon off sections and modules at a time. And then you know just work on it when you can. If you have if you if you're blessed to have management, um, say yeah, go dedicate a team to go and do this. Then get after it and make it make it happen quickly, you know. But um, it's a transition because you know it's a it's a change in thought process more than anything. I got it. So in this case, what size of the business should take this new process into consideration? Should all size of a business, or just certain certain categories of them? Um, is it tough? It's a tough question. Obviously, it boils down to what is your team ready to do and what is your business ready to do. So I guess the way I qualify that is there's a lot of there's a lot of companies in Salesforce that are small to small to medium, and those are the companies that don't really have large IT shops at all or or IT shops at all. And I don't think those people are going to go into the realm of DX. The need is less there, and there they don't have people

[40:15] to support them going forward. And so I think that that that's definitely one group that probably won't go into the world of DX or DX won't affect them that much. You know, businesses that have large code bases. Any business that has multiple production orgs is probably a very large organization and has large IT shops. But basically, you're going to need an IT shop that understands these concepts that we knew in other languages like Java and .Net about you know code organization and architectural principles. But if you if you have any kind of that. You know, if you if you're in in an environment that has lots of issues with deployments and change sets are problematic and and there's always gaps in the change set and it's missing and it's and it's a struggle to understand what went from development to test and then test to production. That's where DX packaging will help tremendously with that. You know, we you know those are those are types of things I say. I guess one caveat right now is another caveat right now is. Is how much code do you have that is programmatic, Apex-based, Visual Force, Lightning component development, that type of thing, versus process builders and Visual Flows. Process builders and Visual Flows are easier for non-technical people to implement and implement very complex logical processes, but in doing so.

[41:45] There, I have seen environments. It's it's a struggle to understand best practices that you would normally see in a traditional IT shop. And so those best practices don't always emerge in the process builder and Visual Flow environments. And so that's going to be difficult to, again, break those process builders and Visual Flows up into modules and allow you to separate that out. It's doable, but it's going to be it's going to be a struggle because again, typically process builder and Visual Flow developers aren't. Don't have the background of, of say, a more programmatic or developer type background, so they're not going to be looking for those types of things. So should businesses do it? No, but you know, again, what does your shop really need to do? Yeah, still a case by case stuff. Oh yeah.

[42:37] So the last question before I let you go is the the video we talk we're talking about now has been a while released has been a while. So do you have any updates after that? Things happened or or new releases, new new exciting I don't know open source plugins to help you to do a easier job. Um. So have there been updates to the Trailhead video? Most definitely. Um. Salesforce had me out to a webinar last summer. We talked some more of the progress, some more of the the concepts that we've been talking here. Is it also recorded? It is recorded. It is available. I can pass you the link. Okay. Yes. Please. We will put it in our show notes again. And then, and then there was a there was a large request from the community for. More in depth examples of what it was that I was talking about at the Trailhead DX session. So I put on a Dreamforce session with another gentleman named John Story, and he he was the developer with me at the law firm, and we go into we go into the weeds of the code about how we achieved a lot of these things, a lot of these different processes. The dynamic, the platform event dynamic subscriptions, you know, dependency injections with the application factory from the Apex Common,

[44:07] and just how we started to improve on that. So. You know one of the one of the enhancements that we did over the summer, Andy Fawcett from Salesforce, he's the VP of Engineering over the DX, among other things, the DX department and whatnot. He and I got into a long discussion about the techniques that we used at the law firm, especially around this dependency injection concept. And he realized that while it was a good concept, it was homegrown, if you will, at the law firm, and we needed a solution to give the community. So it was a a generic open source division. So Andy, myself, and a third developer named Doug Ayres, who's also the He works for Salesforce, designing all of the content, the technical content for the Trailhead areas. The three of us put a new open source project out there called the Force Force DI or Force Dependency Injection. We modeled it after the Google Juice framework, which is a leading dependency injection framework in the world of Java. And you know it's it's available now. I can send you the links and stuff like that. And then in the later in the the two implementations that I've been doing since the summer, we've revamped the the whole approach a little bit to incorporate this Force DI project. And so again, the the Dreamforce talk highlights the inclusion of that.

[45:38] I encourage everybody to check out this Force DI framework because it is much more than just dependency injection for Apex. It brings dependency injection to all facets of Salesforce development: process builders, Visual Flows, Visual Force pages, Lightning pages. It's an incredible framework. Especially a lot of the the enhancements that Andy Paulson and Del Gears, especially, made to it. It just the the scope of that thing is awesome and the power of it. And then then again, the Dreamforce talk highlights how we just sort of combined these three open source code bases and and knitted them together. There's a there's a fourth. Example code base out there on GitHub that basically ties all these three together and just becomes a a nice simple starting point. There's a couple of different people out there that I've talked to that are taking all of these code bases and beginning the process themselves. So yes, there's been lots of improvements. There continue to be improvements as we implement and as we see the need for new features or new approaches and stuff like that. But Dependency injection as a foundation has just made the entire transition to DX completely possible. Without some sort of dependency injection, I doubt we would have been able to do any kind of real adoption of DX at all. I mean, there's just so many different ways that helps stuff like that. So, so yeah, it continues to be very active,

[47:09] very alive, very moving, quite a bit, and lots of improvements. All right, thanks, John. I think this is the excellent place for us to end the session, and I really appreciate you know come to the show to share your experience and especially your contribution back to the the open community. So thank you, thank you a lot, John. Thank you for having me. All right. So let's keep in touch and talk you later. Bye bye. Bye bye.

[47:39] Hi. I'd like to thank you very much as you have reached the end of the show. If you find our content useful, please let me know and connect with me. If you are using Twitter, don't forget to let me know the number one point you have learned in this episode. All the information about the show, about me, the RSS, the iTunes, my Twitter, the newsletter, and the other episodes can be all found at our website SalesforceWay dot com. So thank you again, and see you next time.

Leave a Reply