Github user meniluca commented on the issue:
https://github.com/apache/zeppelin/pull/2195
@zjffdu I agree in principle, but if you look at the code they are few
rather trivial new methods, all of them wrapping up the already existing
``run()``. I have these function running in my notebooks since 1.5 versions, I
don't think you have to worry about backwards compatibility and maintenance too
much (they are really simple!). I'll add screenshots later, but it's easy to
imagine what they do.
Say that I am in the middle of the notebook and I want to run all
paragraphs before a certain point, I will run ``z.runAllBefore`` and that's it.
In the same way if I need to run the rest of the notebook I will use
``z.runAllAfter``. Those functionalities are really useful if you are building
a notebook with complex dynamic forms usage and they will avoid the user to
click repeatedly the run button.
In Jupyter buttons and shortcuts that are doing this are already present,
hence I think that sooner or later you will need those functions.
To describe quickly the other 3 functions... Say that I have one block
where I setup variables and I want other paragraphs to be updated, instead of
issuing:
```scala
val maxAge = z.input("maxAge", 30) // select age and run paragraphs
z.run("parID1")
z.run("parID2")
z.run("parD3")
```
I will have
```scala
z.run("parID1","parID2","parID3")
```
or, even more useful, to avoid repetitions
```scala
val arrayIDs = Array("parID1","parID2","parID3")
z.run(arrayIDs:_*)
// in another paragraph
z.run(arrayIDs:_*)
```
Similarly the function ``z.run(int... idx)`` is doing the same thing,
meanwhile ``z.runNext(int N)``, runs the following N paragraphs. Imagine I have
the same groups of three blocks in sequence and every time I need to update a
variable:
```scala
var maxAge = z.input("maxAge", 30)
z.runNext(3)
// following 3 paragraphs are executed
// ... later, in another paragraph below, $maxAge is updated
maxAge = df.where("balance > 2000").max("age").collect()(0)
z.runNext(3)
// and so on...
```
Anyway, most of them are meant to be more user-friendly wrappers of the
``run()`` functions, syntactic sugar. The most important are the
runAllBefore/After in my opinion. Let me know what you think and how I can be
of any help.
Cheers,
Luca
---
If your project is set up for it, you can reply to this email and have your
reply appear on GitHub as well. If your project does not have this feature
enabled and wishes so, or if the feature is enabled but not working, please
contact infrastructure at infrastruct...@apache.org or file a JIRA ticket
with INFRA.
---
