Anyone who knows me well knows that Easter is my favorite time on the Christian calendar. Without Easter mankind would be hopeless! In the course of three days, our sin-debt was paid off and we had the example of resurrection to give us hope for our eternity.
Anyway, I worked up a script and shot the following with the son of our music minister at Crosslink Community Church. Hope that you like it as much as we enjoyed making it.
The title says it all. Ever since the CC model appeared, the Adobe video tools have been on a steady march downhill. The march is that of reliability and the march is that of robustness. I had to make my feature documentary “The Regulators” using Sony Vegas Pro 13 because Premiere Pro CC had a slew of unbelievable problems. That was CC 2014 but now that I am on CC 2015.2, there are still unbelievable issues plaguing it AND plaguing their flagship After Effects!
Maybe it is the new licensing model that has made Adobe lose its competitive edge. Before, they had to strive to produce awesome software that would entice folks to loosen their pocketbooks and purchase such expensive software. However, everytime that they did, they felt good about what they had done…the software allowed them to get their work done and, even if a problem popped up, their tech support worked diligently to get around the issue. Now, they don’t have to care that much – every month or year, a subscription is collected from the umpteen suckers like me who hold out hope for things to improve.
Case in point – here I am sitting for a 28 second segment of video to render. It is taking over 2 minutes to render 1 second of video which is already prerendered to previews! Note that I am not strapped for memory and my processing power is not necessarily a slouch. There is nothing spectacular in the segment in question – just some H264 video with an UltraKey.
This goes hand-in-hand with a very weird problem in After Effects CC 2015.2. The segment is a very simple Shatter and yet produces a phantom garbage frame in the middle of any render. Tech support was brought in on it last Friday and has nothing to offer yet. My question is, if AE doesn’t do its basic functionality then why have it? Why pay for it?
So, once again I find myself at the crossroads. I have Sony Vegas but really don’t feel it produces the absolute best. It certainly doesn’t feel as polished and nice as Adobe’s products do when they work properly. FCP is an interesting option but I will definitely need to make a very large paradigm shift in my life to go with it.
I just wish that Adobe would get its act together…
(Nov 23, 2015 – To add insult to injury, I went to purchase a piece of Adobe Stock a few minutes ago just to have the cart crash while checking out. “Your purchase cannot be completed due to an internal error. Please call xxx-xxx-xxxx for immediate sales assistance.” Really? Purchase carts are common and relatively easy to handle and yet Adobe can’t even get THIS right? What a mess….)
In reading the passage in 1 Sam 17 (which even non-Bible readers people have heard in story form as David and Goliath), it is readily apparent that faith is key. For most of the players in the Biblical account and for most hearers, faith is not of prime importance. They either consider David foolishly headstrong, extremely lucky, or an expert marksman. Yet, a careful reading of the passage reveals that David was completely driven by his faith and he did not rely upon his own strength or luck.
“David slays Goliath” by Gustave Doré (1866).
Let me begin by summarizing the scene as described in 1 Sam 17:1-10. The armies of Israel and Philistia were lined up across from one another with a valley through which coursed one or more streams between them. It appears by reading between the lines that the assessments of troop strengths on either side by the other made them about equal so that neither side would charge across the exposed valley at the other. There is also the question of the tactics of either army leaving the security of the high ground on their side and permitting themselves to become sitting ducks in the exposed valley. King Saul and the army of Israel found themselves at an impasse.
From King Saul’s point-of-view, his keeping the army dug in was central. As long as they were dug-in, they were not losing ground. Faith in God intervening and being able to overcome the obstacles of the valley and the opposing army was something that may have received lip service, but it was not something in his core. Since faith is the same thing as trust, we can restate this as Saul did not really trust God to fight for Israel. The edge of that valley marked the limit of Saul’s faith in God. We learn also that Saul considered his kingship central to his life also. Reading between the lines (again) we see in verses 31 and 32 that he was very concerned that if a champion of his were to lose, he would be in dire straights of losing what was important to him.
Israel’s belief was also stymied in the same way as King Saul’s and such is the faith of many of those who profess it — it is something that one can talk about, “but, you know, God really cannot and does not move in today’s circumstances.” Such faith is superfluous and, in the words of James, “What does it profit, my brethren, if someone says he has faith but does not have works? Can faith save him?” (James 2:14 NKJV) He is not describing works as things that we can do to appease God. He is describing works as those acts and actions that are driven by and work in conjunction with a powerful, living faith and so become solid as soon as the believer steps out on them. Frankly, superfluous faith is the faith of losers.
To further complicate the conditions surrounding the situation, we must now pay attention to the loud, profane words of a giant warrior from the Philistine side. Goliath, towering at about nine and a half feet, stepped out into the no-man’s land of the valley with his armor bearer and shouted at the Israelite army (1 Sam 17:4-11,16,23-25). He, according to the Biblical narrative, had done this for the past 39 days. He was big, boastful, and brash. He shouted defiance to the enemy army dug-in on the opposite hillside to his Philistine compatriots. His faith was solidly placed equally in his own strength and his armament. From his perspective, God was some sort of mythical being invented by the Israelites who were cowering in fear across the way. His assumption was bolstered by the lack of power of their “God” over the past 39 days.
On this momentous day, something different occurred. A young teenage shepherd-boy named David had been sent by his father to the Israelite army placements to drop off some care-packages for his older brothers (1 Sam 17:12-15,17-22). This young man happened to be there to witness Goliath’s 40th day of stepping out and shouting his twice-daily challenge (verses 23-25). He watched in dismay how the armies of Israel cringed and ran back to their secure emplacements in retort to the giant’s challenge.
Even before this moment, we are led to understand that David placed his full trust in God. His faith was central to who he was. You could not separate David the person from David’s faith. He fully grasped that God is solid and real as anything he could see and touch. He knew that God is able to accomplish anything that He willed. In verse 37, David enunciated his creed: “The Lord, who delivered me from the paw of the lion and from the paw of the bear, He will deliver me from the hand of this Philistine.” (NKJV) There is no sign of doubt or indication of dependence upon his own strength on David’s part. He recognized that it was God who wielded power to kill the lion and the bear in his earlier experience (verses 34-36) and he knew that God was moving him to become His tool to obliterate the foul-mouthed Goliath!
Faith sets all problems in their proper perspective and places them in their right track. Hebrews 11:1 states that “Now faith is the substance of things hoped for, the evidence of things not seen.” In other words, faith is not some sort of foolish wishful thinking. It is not a matter of looking to God as if He were some cosmic genie Who grants us three wishes! Instead, faith is sure hope based upon the believer’s completely meshed understanding of God’s will for and His call upon their lives. It is this sort of concrete faith that formed the scaffolding which under-girded the life of this young shepherd-boy.
The other party in this encounter is the army of the Philistines. What was central to them? Obviously it was Goliath’s strength. They virtually projected his strength into their own arms, which we can infer from the last sentence in verse 51, “And when the Philistines saw that their champion was dead, they fled.” When Goliath fell, so did all the tenets of their beliefs! They held the same disregard for God that Goliath did so when God showed up in the valley, they did not know what to do. When one assumes that God does not exist or that “all things work together for good to those who love God, to those who are the called according to His purpose,” (Rom 8:28 NKJV) then one is shocked when He turns up.
I believe that we all know the key parts that jump out of the Biblical documentation: how David was “on fire for the Lord;” how he stepped into the valley and picked five stones (one for Goliath and one to represent the rest of his brothers, Rapha’s sons); and how he confronted the giant. What is important for us to glean from David’s sureness is that if concrete faith in a real God Who has a concrete will is not central to the person, no other assumption will stand. David aimed his sling but deep inside his heart, he knew that it did not matter where he aimed. The victory was not going to be his by skill and marksmanship. I am convinced that even had David had randomly slung that stone in the opposite direction, by God’s intervention it would still have found its mark squarely in the center of Goliath’s forehead.
David knew beyond any shadow of a doubt that the victory belonged to the Lord and that He had an important point to make. The beneficiaries of that point were all of the people mentioned above. Israel and King Saul were about to learn that one faithful person can move a mountain, or at least a mountainous-sized person. The Philistine army were on the brink of learning how stinging defeat is to those who rely upon the arm of flesh. Finally, Goliath was about to eat his blasphemous words as he transitioned to God’s judgment!
Even David himself benefited because he learned once again how God expressed His will to him and how He gave him the victory from not only from the paw of the bear and the paw of the lion, but also from the might of the Philistine giant. Obedience in faith to God’s will begets greater faith. In spiritual stature, David towered over Goliath because he was a super-giant of faith who was fully dependent upon an infinite God rather than upon feeble flesh.
Now the circumstances of 1 Samuel 17 need to move forward 3000 years to the here and now. The questions and beliefs from then still surround us today. Which character best describes you? Upon whom or what do you place your faith? Are you like David who wrote “The Lord is my light and my salvation; Whom shall I fear? The Lord is the strength of my life; Of whom shall I be afraid?” (Psalm 27:1 NKJV) or is your faith built on something else? If you don’t have a concrete faith in a real God, then how reliable is that something else in the light of all eternity? Consider the comparison God raised in Habakkuk, “Behold the proud, his soul is not upright in him; But the just shall live by his faith.” (Hab 2:4 NKJV) God’s position on faith is stated in Hebrews 11:6 “But without faith it is impossible to please Him, for he who comes to God must believe that He is, and that He is a rewarder of those who diligently seek Him.” (NKJV) Faith is the beginning and the lifeblood of a vibrant relationship with God. The gist of this is that without active faith being front-and-center in one’s life, there is no relationship.
So, let each of us ask ourselves where our faith lies….
As is the case for everyone on Earth, time is a very fickle and scarce resource for a developer. It must be managed carefully in order to ensure that the payoff of time-investment is maximized. There are several practices which assist a developer and a development team to ensure that their time investments are legitimate.
In considering time, we live in the moment called “now.” Now is always bright and clear and is wedged between the past (which tends to become murky and stuffy) and the future (which is completely opaque and unfathomable).
In terms of the developer’s life, the old saying “there is no time like the present” really is true. The only things we can be certain of are in the past or are currently occurring. The future becomes less and less certain as one looks forward. We must attempt to aggregate as much important work as we can into the here-and-now. Yet, too often, developers try to put things off and push them down into the dark cloud of the future with expectations that the future is set in stone. This is the source of so much chagrin in life. The future becomes dark and unfathomable very quickly (maybe within minutes of “now”).
All of us must understand that there is precious little that one can do about the future other than to hedge bets. Of course, there is nothing wrong with planning, but all planning should also include contingencies. What if the planned event doesn’t come to pass as expected or even at all? Of course, the lack of planning in key areas of life is the hallmark of foolishness.
The problem arises when we willingly decide to throw items that we should deal with here and now down the road to some undetermined time. The more that we develop this bad habit, the more undependable we become to our peers, our management, and our business partners. We will miss deadlines (which we consider to be mere paper-walls drawn across our future), rush to create careless code as time dwindles, or exhaust ourselves with overnighters as we try anxiously to pay off the promise-debts we incurred for ourselves in the first place.
Proper time and task management is of crucial importance to handling the workload but this must be coupled with a strong and unwavering discipline that enforces the fact that work destined for “now” cannot be pushed into the future unless there is some overriding need (e.g. a priority reshuffle, the breakdown or failure of a critical resource, a crucial life event, etc.). Even when something must be delayed for a legitimate reason, it must still be handled with proper discipline to prevent it from “falling through the cracks.”
As many who know me would agree, I am an advocate for Agile development processes. A technique such as Scrum brings a strongly-manageable understanding of the tasks slated for “now” and for the very immediate future. The backlog extends in both directions, encompassing the past and embracing the future. The lessons of the past feed forward into the” now” and immediate future by using past team performance to predict a reasonable and achievable set of goals within the short sprint timeframe. However, Agile processes by themselves do not overcome the individual developer’s need for disciplined time and task management.
It is incumbent upon each member of the team to consider the effect of delay upon themselves, upon the project, and upon their peers. While both life-events and work-events (e.g. Email, calls, production issues, health problems, family issues, business events) will interrupt a developer’s workday, planning blocks of time and allocating them to meet the current “now” development needs should be a part of one’s daily calendar. There is no problem with pre-planning the next few days, but always with the understanding that the future is fluid and changing. The best way to ensure you are not pressed for time towards the end of projects, deadlines, and sprints is to do the bulk of the work upfront while “now” is now. Essentially, the effort curve towards any deadline should be front-loaded.
Remember, the key is to ensure that contingencies in the future are anticipated. By concentrating on the bulk of the work (and the more difficult and intricate parts of the work) up-front, one minimizes the possibility that the future can cause excessive amounts of work, overtime, or sloppy coding as the deadline looms. Try as much as possible to eliminate the source of such frustration. Do not be glib in throwing any task “down the road” for any reason other than one which forces one’s hand.
At times, procrastination can be a good thing to a project as long as it is a group-mediated procrastination effort. Many times, seemingly great ideas for product additions and changes, or for refactoring may bubble up within the business and development teams, but when examined though the prism of time are either not so great or not as pressing as originally imagined. This is where processing ideas through an Agile process backlog grooming approach really pays dividends since the truly critical functionality tends to bubble up into the current sprint and the fluff tends to be pushed down deeper into the backlog stack.
In closing, it is my habit to advise every developer I meet to avail themselves of a good time and task management class. This is beneficial and can provide an excellent external source of control to the mayhem of planning for “now.” However, one also has to develop a strong habit of being disciplined in following the task and time management goals. This cannot be taught, it must be acquired and cultivated. I can assure you that if you do, you will be a more productive developer and able to accommodate unexpected future events with less stress and anguish.
It has been a while since I have actually posted a “rant” against software craziness. However, now is the time to let loose on a trend which has completely dominated our software world. Usability is not accorded the respect that it requires. It appears that development teams do not apply the logic of “how will our users use this application,” especially in the world of web and mobile programming.
As you can see above, this is a part of the mobile website for Pizza Hut. I am picking on this site specifically because yesterday I ran into a major usability issue. My wife and I were driving from North Carolina to New Orleans and had a hankering for some good old Pan Pizza. Since I was riding shotgun, I pulled up the Pizza Hut website to be greeted by the garbage above (mobile.pizzahut.com).
The “garbage” is not in the appearance. It is not even in the “I want to order a pizza from my hometown store.” Where it lies is in the fact that the designers and developers never ONCE seemed to have considered the first word in the website address: “mobile.”
Mobile signifies that someone is on the move and while that person 7 times out of 10 may be using their phone to order from their local store, the other 30% of the time it is being used by someone who desires to find a store! Look at the menu on the page…nothing about “store locator” is there.
In fact, the only thing under “About us” is “Careers.” Really?? Is the most common use of a restaurant chain website on a mobile app apart from ordering pick-up or delivery the quest for a job? No freakin’ way!
Now, don’t get me wrong. I don’t care that they have ordering or career searching on their mobile site. I DO care that there is not a single link for finding a restaurant. BTW, I forced my phone to get the normal website and there was an option there to find restaurants but they still did not provide the information that we most needed as we cruised down I-65 at 70mph.
I knew from Googling for Pizza Hut restaurants near Mobile, Alabama that there were a few in town. The question that Google did not answer, and Pizza Hut’s site did not either (to their shame), is whether or not the locations were full-service restaurants or just carryout locations!!
Folks, let me appeal to you if you are involved in development. Please consider all the possible use cases for your customers’ use of the various parts of the website. Usability is a prime factor in reducing frustration. BTW, other restaurant sites were very easy to use to find locations. They prominently exposed this functionality to their mobile users.
Anyway, we determined to go to one of the Pizza Hut locations which was next to a Five Guys restaurant. We decided to give it a look-see and if it indeed was a dine-in Hut, we would go there. Otherwise, we would fall-back to the Five Guys option. It was a good decision…the restaurant was a dine-in and the service and piping-hot food was absolutely incredible. We almost gave up on a good dining experience because of poor software design!!
(Note: The images above are taken from the mobile Pizza Hut website as of 5/1/2015. The content is copyright its respective owner…the images are to illustrate the point of this blog. My beef is not with Pizza Hut itself but with the software development and business use-case teams.)
It has been ages since I have posted a software development post. The last week, I have been working on some MVC 4 code and had to figure out how to do server-side support for the most excellent DataTables package. This, of course, triggers off AJAX requests whenever data is required to populate the on-screen client-side gridview table.
If you are using the DataTables package prior to v10 or use it in compatibility mode then you don’t have many problems because the JSON generated to the AJAX service is not built with arrays and complex data. This compatibility is triggered by using the sAjaxSource parameter or by setting $.fn.dataTable.ext.legacy.ajax to true. However, what is the point in a new project to depend on backwards compatibility that may go away in the next version of the library?
The server side support for DataTables is documented here. Information on how to use it in v10+ mode with MVC is slim on the net so one has to cobble together a solution based upon several different sources especially if one plans to create a simple ApiController to handle the AJAX callbacks. I am sharing what I have discovered for whatever it is worth to anyone facing the same hurdles I did and hope that it does help.
First of all, here is the page code for the DataTables on the website:
.
.
.
<!-- Kick off rendering of DataTable -->
<script type="text/javascript" language="javascript">
$(document).ready(function () {
$('#CountryTable').DataTable({
serverSide: true,
ajax: {
url: '/api/data',
type: 'POST',
contentType: 'application/json; charset=utf-8',
data: function(data)
{
return data = JSON.stringify(data);
}
}
});
});
</script>
<h2>Countries</h2>
<table id="CountryTable" class="display" cellspacing="0" width="800px">
<thead>
<tr>
<th>ID</th>
<th>Code</th>
<th>Country name</th>
<th>Currency</th>
</tr>
</thead>
<tbody>
</tbody>
</table>
.
.
.
Let me share a couple comments concerning the code above. Notice that DataTables wraps the standard table (CountryTable) which, as you will notice does not have any body items. This, and the ajax verb in the Javascript code, will trigger DataTables to work in the server-side mode. Notice that the ajax function is defined with a type of POST (we will capture this on the server side) and the contentType MUST be specified otherwise the string will not be interpreted by the ASP.NET side as being JSON. One of the most common mistakes in working with JSON in either direction is to miss setting the JSON content type and the resulting string is interpreted as just plain text by the AJAX mechanism.
So, how to capture and process this AJAX request in MVC 4? There are several options, of course, but I chose to vector through the standard ApiController.
public class DataController : ApiController
{
public HttpResponseMessage Post(Newtonsoft.Json.Linq.JObject param)
{
return HandleRequest(DataTableRequestModel.DecodeDataTableRequest(param));
The AJAX call to /api/data will vector to look for a controller named DataController in MVC. This controller extends ApiController and handles the POST request by exposing a Post method. The method could be named something else and merely be decorated with an [System.Web.Mvc.HttpPost] attribute. Dealer’s choice on that one.
Notice that I capture the parameter as a JObject. It could have been created like this:
public HttpResponseMessage Post(DataTableRequestModel param)
which would have decoded the non-complex items automatically using the Model class below but there is no way to decode the complex items out of the box. If one feels really adventurous, it is possible to write your own binder code but since the JSON from DataTables is not really too complex, I chose to handle it externally. The JObject is initialized with the JSON from the call (since the content type was set to application/json) and so the data is ready to be plucked from the object. In the Models folder, I created a generic DataTableRequestModel with the fields expected from the request:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
namespace MVCGridTester.Models
{
// See article by Chris Laforet (claforet.wordpress.com)
// Sample request sent JSON stringified:
//
//{"draw":1,"columns":[{"data":0,"name":"","searchable":true,"orderable":true,"search":
//{"value":"","regex":false}},{"data":1,"name":"","searchable":true,"orderable":true,"search":
//{"value":"","regex":false}},{"data":2,"name":"","searchable":true,"orderable":true,"search":
//{"value":"","regex":false}}],"order":
//[{"column":0,"dir":"asc"}],"start":0,"length":10,"search":{"value":"","regex":false}}
//
/// <summary>
/// Class that encapsulates common parameters sent by DataTables plugin
/// </summary>
public class DataTableRequestModel
{
/// <summary>
/// Since the DataTableRequest includes arrays of data elements (columns, order), it cannot be
/// correctly parsed out in its entirety by the native API which only handles single root-level
/// elements. This static call can take the raw JSON object and populate the DataTableRequestModel
/// correctly.
/// </summary>
/// <param name="param">The passed in JSON object from the POST</param>
/// <returns>A DataTableRequestModel populated with the correct data</returns>
public static DataTableRequestModel DecodeDataTableRequest(Newtonsoft.Json.Linq.JObject param)
{
dynamic json = param; // recast the parameter as a dynamic object
DataTableRequestModel dtr = new DataTableRequestModel();
dtr.draw = json.draw;
dtr.start = json.start;
dtr.length = json.length;
dynamic columns = json.columns;
if (columns != null)
{
List<DTRColumn> list = new List<DTRColumn>();
foreach (dynamic token in columns.Children())
{
DTRColumn c = new DTRColumn();
c.data = token.data;
c.name = token.name;
c.searchable = token.searchable;
c.orderable = token.orderable;
dynamic columnSearch = token.search;
if (columnSearch != null)
{
DTRSearch s = new DTRSearch();
s.value = columnSearch.value;
s.regex = columnSearch.regex;
c.search = s;
}
list.Add(c);
}
dtr.columns = list;
}
dynamic order = json.order;
if (order != null)
{
List<DTROrder> list = new List<DTROrder>();
foreach (dynamic token in order.Children())
{
DTROrder o = new DTROrder();
o.column = token.column;
o.dir = token.dir;
list.Add(o);
}
dtr.order = list;
}
dynamic search = json.search;
if (search != null)
{
DTRSearch s = new DTRSearch();
s.value = search.value;
s.regex = search.regex;
dtr.search = s;
}
return dtr;
}
/// <summary>
/// Draw counter. This is used by DataTables to ensure that the Ajax returns from server-side processing requests are drawn in sequence by DataTables
/// </summary>
public int draw { get; set; }
/// <summary>
/// Paging first record indicator. This is the start point in the current data set (0 index based - i.e. 0 is the first record).
/// </summary>
public int start { get; set; }
/// <summary>
/// Number of records that the table can display in the current draw. It is expected that the number of records returned
/// will be equal to this number, unless the server has fewer records to return. Note that this can be -1 to
/// indicate that all records should be returned
/// </summary>
public int length { get; set; }
/// <summary>
/// Comma separated list of orderable column data.
/// </summary>
public IEnumerable<DTROrder> order { get; set; }
/// <summary>
/// Comma separated list of column data
/// </summary>
public IEnumerable<DTRColumn> columns { get; set; }
/// <summary>
/// Global search value. To be applied to all columns which have searchable as true.
/// </summary>
public DTRSearch search { get; set; }
}
/// <summary>
/// Encodes an Order from within the Data Table Request
///
/// "order":
/// [
/// {"column":0,"dir":"asc"}
/// ]
/// </summary>
public class DTROrder
{
public const string ORDER_ASCENDING = "asc";
public const string ORDER_DESCENDING = "desc";
public int column { get; set; }
public string dir { get; set; }
public bool IsAscending
{
get
{
if (dir != null && dir.CompareTo(ORDER_ASCENDING) == 0)
return true;
return false;
}
}
}
/// <summary>
/// Encodes a Search within a Column from the Data Table Request
///
/// "search": {"value":"","regex":false}
/// </summary>
public class DTRSearch
{
public string value { get; set; }
public bool regex { get; set; }
}
/// <summary>
/// Encodes a Column from the Data Table Request
///
/// "columns":
/// [
/// {"data":0,"name":"","searchable":true,"orderable":true,
/// "search": {"value":"","regex":false}
/// },
/// {...}
/// ]
/// </summary>
public class DTRColumn
{
public string data { get; set; }
public string name { get; set; }
public bool searchable { get; set; }
public bool orderable { get; set; }
public DTRSearch search { get; set; }
}
}
Not a lot of complication here. Notice how the array and complex types are handled by simple container classes. In order to populate the data, it is merely a matter of walking the JSON string and loading the contents of the model. Many of the ideas in the parser were developed based upon this blog article by Rick Strahl so if you want to delve deeper into the how and the why everything works, give it a read.
At the end of the process, one has an object containing every element in the DataTable’s request. These items can be actioned by the data manipulation code (e.g. selecting, sorting, filtering) and returned as a JSON string. The implementation of this data manipulation and the construction of the return string are left to the reader.
So, that’s all there is to it. Happy coding!
As an observer of the Church, it never ceases to amaze me how Christ’s simple call to his disciples that “if anyone desires to come after Me, let him deny himself, and take up his cross, and follow Me” (Matt 16:24 NKJV) is completely ignored. We all bring our expectations, greed, and desires to the foot of the Cross and then demand that God accept the whole package.
While it is true that this occurred ever since the beginning of the church (see 1 Corinthians for a good example), it seems to have become a de facto standard in Christendom in today’s world. People approach the altar expecting it to be laid out as buffet of God’s requirements of which they can pick and choose what they might deign to put on their plates.
“Yes, I want a side of God’s love but leave off His justice, please.”
“Mmmmm, give me a couple spoonfuls of sweet compassion but no, there is no need for God’s judgement on my theological plate.”
“Slather on the justification but who needs a side of relinquishing lordship to Jesus?”
“Yeah, I can enjoy a good dessert of Christ’s sacrifice for sin but who wants to hear about Hell?”
“Give me a healthy scoop of sanctification so I can cover over the immoral behavior I refuse to give up.”
“I can’t get enough of that salvation but that righteousness is too sour for me to tolerate.”
“Yep, give me some good old contemporary Christian music…it is so much better to hear the gospel sung than to read the Word of God.”
Wasn’t Jesus’ requirement clear enough? He expects us to deny ourselves, to empty ourselves of everything as He did, and to take up the cross upon which we must sacrifice everything as we constantly follow him. Luke 9:23, the parallel passage to this inserts the word “daily” into the commandment. Every morning we have a choice, to choose to follow Christ in abject obedience, or to prefer to be the lords of our own destinies.
So today we have a weak Church filled with weak Christians (see How to Reform the Church). The picking and choosing has helped splinter Christ’s Body into millions of little pockets. Even within any single denomination, there are microcosms of smorgasbord belief that actually separate church from church. Although they may pay lip-service homage to the fact, Jesus is not the Lord of His Church, at least in the hearts of many (maybe even most) Christians. The underlying root of this is a desire for Lordship but no desire for Surrender.
It is imperative for this discussion to expand the context of the passage quoted above. “Then Jesus said to His disciples, ‘If anyone desires to come after Me, let him deny himself, and take up his cross, and follow Me. For whoever desires to save his life will lose it, but whoever loses his life for My sake will find it. For what profit is it to a man if he gains the whole world, and loses his own soul? Or what will a man give in exchange for his soul? For the Son of Man will come in the glory of His Father with His angels, and then He will reward each according to his works….’ (Matt 16:24-27 NKJV)
One can boil this passage down to Jesus saying, “Pick a side!” If you want to follow Him, you must deny yourself. If you don’t, you are not following Him. If you want to follow Him, you must take up your cross daily. You must choose to sacrifice anything that gets between you and Him. If you don’t, you are not following Him. If you want to have a cushy life instead of letting it be dedicated to Him, then you are not following Him. Pick a side!
The Christian life is not a buffet that we choose from. When we surrender our all to Christ, He gets to put the things on our plate that He knows will profit us and His kingdom. We must accept what He gives us and let our faith and trust in God’s incredible wisdom override our petty and limited human vision. There can never be true service without complete submission. There can never be Christ’s Lordship without a total surrender of ourselves. For me to be a true disciple of Jesus Christ, there has to be (as Oswald Chambers stated) a relinquishing of the rights to myself.
Which brings me to my final point. It is too common for people to desire to apply the moniker of “Christian” upon themselves without any desire to abandon moral failures. This is the schism we can easily see throughout the people of the Church today. There is a Sunday morning persona which is all pious and loving and then there is a “rest-of-the-week” persona which indulges in immorality, hatred, lies, faithlessness, and filthy talk. The name of Christ is tarnished in the world. Almost reminds me of Paul’s admonition to the pious Jews in Romans 2:21-24, the highlight quote which I will appropriate and rephrase as, “For the name of God is blasphemed among the world because of you….”
The call is certain and specific. We are not invited to a buffet spread out at the foot of the Cross. We are invited to a decision, one with deep ramifications either way. May we be sober-minded and deliberate in picking Christ’s side and may we be committed to following Him every day wherever He leads…only if He is truly our Lord will the Church reflect Him.
